//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.42000
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace Resources {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option or rebuild the Visual Studio project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Web.Application.StronglyTypedResourceProxyBuilder", "14.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class MultiRowExplorer {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal MultiRowExplorer() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Resources.MultiRowExplorer", global::System.Reflection.Assembly.Load("App_GlobalResources"));
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;MultiRow&lt;/b&gt; control has built-in support for Excel-like, fast, in-cell editing.&lt;/br&gt;Users can begin editing by simply typing in to any cell (quick-edit mode), or by pressing F2 or clicking a cell twice (full-edit mode).&lt;/br&gt;There is no need to add extra columns with &apos;Edit&apos; buttons that switch between display and edit modes..
        /// </summary>
        internal static string BatchEditing_Text0 {
            get {
                return ResourceManager.GetString("BatchEditing_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to There are two modes for updating data to server..
        /// </summary>
        internal static string BatchEditing_Text1 {
            get {
                return ResourceManager.GetString("BatchEditing_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In this mode, which is the default mode, the item updated or created gets committed to the server once the corresponding row finishes editing.&lt;/br&gt;The removed row will be committed to the server immediately..
        /// </summary>
        internal static string BatchEditing_Text2 {
            get {
                return ResourceManager.GetString("BatchEditing_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If user wants to update the data, the Update action Url should be provided. If one wants to add or remove the data, the Create or the Delete action Url should be provided.&lt;/br&gt;And the user should edit the data in the corresponding action..
        /// </summary>
        internal static string BatchEditing_Text3 {
            get {
                return ResourceManager.GetString("BatchEditing_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In this mode user can update, create or remove multiple items and commit all the changes to the data source once.&lt;/br&gt;The user can commit multiple modifications by sorting, paging or filtering the grid data or simply on a button-click..
        /// </summary>
        internal static string BatchEditing_Text4 {
            get {
                return ResourceManager.GetString("BatchEditing_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;BatchEditing&lt;/b&gt; action Url should be provided in this mode..
        /// </summary>
        internal static string BatchEditing_Text5 {
            get {
                return ResourceManager.GetString("BatchEditing_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Note:&lt;/b&gt; To disable data update during sort/filter/page operations, set the &lt;b&gt;DisableServerRead&lt;/b&gt; property of MultiRow&apos;s &lt;b&gt;ItemSource&lt;/b&gt; to True.&lt;/br&gt;This will enable client-side sorting, filtering, paging and data will only be submitted when the collectionView&apos;s &lt;b&gt;commit&lt;/b&gt; method is explicitly called from the client-side..
        /// </summary>
        internal static string BatchEditing_Text6 {
            get {
                return ResourceManager.GetString("BatchEditing_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Normal Mode.
        /// </summary>
        internal static string BatchEditing_Text7 {
            get {
                return ResourceManager.GetString("BatchEditing_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Batch Mode.
        /// </summary>
        internal static string BatchEditing_Text8 {
            get {
                return ResourceManager.GetString("BatchEditing_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows the Batch update mode for updating the MultiRow data to server..
        /// </summary>
        internal static string BatchEditing_Text9 {
            get {
                return ResourceManager.GetString("BatchEditing_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows how to collapse the column headers of MultiRow control to a single line, which shows only the group names rather than individual cells..
        /// </summary>
        internal static string CollapsedHeaders_Text0 {
            get {
                return ResourceManager.GetString("CollapsedHeaders_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, the &lt;b&gt;MultiRow&lt;/b&gt; control creates column headers that span multiple rows and shows the header for each cell defined in the layoutDefinition..
        /// </summary>
        internal static string CollapsedHeaders_Text1 {
            get {
                return ResourceManager.GetString("CollapsedHeaders_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to These cell-specific column headers may be used to sort or filter the data as you would do in a conventional grid..
        /// </summary>
        internal static string CollapsedHeaders_Text2 {
            get {
                return ResourceManager.GetString("CollapsedHeaders_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In some cases, you may want to collapse the column headers to a single line, showing only the group names rather than individual cells.&lt;/br&gt;This saves space at the expense of having individual cell headers. To collapse the column headers, set the &lt;b&gt;CollapsedHeaders&lt;/b&gt; property to true.&lt;/br&gt;In these scenarios, remember to set the &lt;b&gt;Header&lt;/b&gt; property on the groups in order to avoid empty column headers..
        /// </summary>
        internal static string CollapsedHeaders_Text3 {
            get {
                return ResourceManager.GetString("CollapsedHeaders_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Setting the &lt;b&gt;CollapsedHeaders&lt;/b&gt; property to &lt;b&gt;null&lt;/b&gt; causes the grid to show all header information (groups and columns).&lt;/br&gt;In this case, the first row will show the group headers and the remaining rows will show the individual column headers..
        /// </summary>
        internal static string CollapsedHeaders_Text4 {
            get {
                return ResourceManager.GetString("CollapsedHeaders_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample demonstrates how to use custom cells feature of the &lt;b&gt;MultiRow&lt;/b&gt; control..
        /// </summary>
        internal static string CustomCells_Text0 {
            get {
                return ResourceManager.GetString("CustomCells_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The sample uses the &lt;b&gt;TemplateId&lt;/b&gt; property to specify the id of the template for the &quot;Trends&quot; column..
        /// </summary>
        internal static string CustomCells_Text1 {
            get {
                return ResourceManager.GetString("CustomCells_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The sample also uses the &lt;b&gt;ItemFormatter&lt;/b&gt; property to customize displaying &quot;Rank&quot; column.&lt;/br&gt;In the ItemFormatter event handler, use the &lt;b&gt;getBindingColumn&lt;/b&gt; function of MultiRow to get the binding column..
        /// </summary>
        internal static string CustomCells_Text2 {
            get {
                return ResourceManager.GetString("CustomCells_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows how you can use custom editors to change the values in the cells of &lt;b&gt;MultiRow&lt;/b&gt; control..
        /// </summary>
        internal static string CustomEditors_Text0 {
            get {
                return ResourceManager.GetString("CustomEditors_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The sample uses the &lt;b&gt;EditTemplateId&lt;/b&gt; property to specify the id of the template for cell editor.&lt;/br&gt;When the user starts editing a cell, the editor will show and get the focus..
        /// </summary>
        internal static string CustomEditors_Text1 {
            get {
                return ResourceManager.GetString("CustomEditors_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In this sample, &quot;Amount2&quot; and &quot;Active&quot; use grid&apos;s internal editor. Here, you do not need to do anything..
        /// </summary>
        internal static string CustomEditors_Text10 {
            get {
                return ResourceManager.GetString("CustomEditors_Text10", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Using C1 Input controls which have &quot;Value&quot; or &quot;Text&quot; property.
        /// </summary>
        internal static string CustomEditors_Text11 {
            get {
                return ResourceManager.GetString("CustomEditors_Text11", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Using other control or a C1 control which has NO &quot;Value&quot; or &quot;Text&quot; property.
        /// </summary>
        internal static string CustomEditors_Text12 {
            get {
                return ResourceManager.GetString("CustomEditors_Text12", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Using grid&apos;s internal editor.
        /// </summary>
        internal static string CustomEditors_Text13 {
            get {
                return ResourceManager.GetString("CustomEditors_Text13", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to There are three kinds of editors..
        /// </summary>
        internal static string CustomEditors_Text2 {
            get {
                return ResourceManager.GetString("CustomEditors_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You need to set the &lt;b&gt;EditTemplate&lt;/b&gt; property of a cell..
        /// </summary>
        internal static string CustomEditors_Text3 {
            get {
                return ResourceManager.GetString("CustomEditors_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If the grid allows adding a new row, you need to set the editor&apos;s &lt;b&gt;IsRequired&lt;/b&gt; property to false.&lt;/br&gt;If you want the editor with the whole cell, you can set the style width to &quot;100%&quot;..
        /// </summary>
        internal static string CustomEditors_Text4 {
            get {
                return ResourceManager.GetString("CustomEditors_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In this sample, &quot;Date&quot;, &quot;Time&quot;, &quot;Country&quot;, &quot;Amount&quot; and &quot;Color&quot; use C1 Input controls as the editors..
        /// </summary>
        internal static string CustomEditors_Text5 {
            get {
                return ResourceManager.GetString("CustomEditors_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You need to use grid&apos;s &lt;b&gt;OnClientCellEditEnding&lt;/b&gt; event and set&lt;/br&gt;&lt;pre&gt;&lt;/br&gt;cellEditEndingEventArgs.cancel = true;&lt;/br&gt;&lt;/pre&gt;&lt;/br&gt;to apply your updates..
        /// </summary>
        internal static string CustomEditors_Text6 {
            get {
                return ResourceManager.GetString("CustomEditors_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Then you need to consider when to update the cell value and remove the editor from a grid in your application.&lt;/br&gt;For example, when the editor blurs, we need to update the cell value and remove the editor..
        /// </summary>
        internal static string CustomEditors_Text7 {
            get {
                return ResourceManager.GetString("CustomEditors_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In this sample, the &quot;Product&quot; column uses &lt;input /&gt; as the editor..
        /// </summary>
        internal static string CustomEditors_Text8 {
            get {
                return ResourceManager.GetString("CustomEditors_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To get the binding column in the event handler, please use the MultiRow&apos;s &lt;b&gt;getBindingColumn&lt;/b&gt; function..
        /// </summary>
        internal static string CustomEditors_Text9 {
            get {
                return ResourceManager.GetString("CustomEditors_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Data maps provide a grid with automatic look up capabilities. For example, you may want to display a customer&apos;s name instead of his/her ID, or a color name instead of its RGB value.&lt;br /&gt;&lt;/br&gt;Columns with an associated data map can be sorted by the mapped display value instead of the binding value.&lt;br /&gt;&lt;/br&gt;Columns with an associated data map, in this sample, show drop-down buttons that can be used for quick editing. If you do not want to show the drop-down buttons, set the column&apos;s &lt;b&gt;ShowDropDown&lt;/b&gt; pro [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string DataMap_Text0 {
            get {
                return ResourceManager.GetString("DataMap_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Multi-column Data Map.
        /// </summary>
        internal static string DataMap_Text1 {
            get {
                return ResourceManager.GetString("DataMap_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The columns of &lt;b&gt;MultiRow&lt;/b&gt; control have a &lt;b&gt;DropDownCssClass&lt;/b&gt; property that enables styling the drop-downs, used to edit values in data-mapped columns..
        /// </summary>
        internal static string DataMap_Text2 {
            get {
                return ResourceManager.GetString("DataMap_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To see the multi-column editor in action, click one of the drop-down buttons in the &quot;Color&quot; column,&lt;/br&gt;or select a cell in that column and press F4:.
        /// </summary>
        internal static string DataMap_Text3 {
            get {
                return ResourceManager.GetString("DataMap_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample demonstrates how to use data map feature, which provides the MultiRow control with automatic look up capabilities..
        /// </summary>
        internal static string DataMap_Text4 {
            get {
                return ResourceManager.GetString("DataMap_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows how to disable server-side reading in MultiRow control..
        /// </summary>
        internal static string DisableServerRead_Text0 {
            get {
                return ResourceManager.GetString("DisableServerRead_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows what the &lt;b&gt;DisableServerRead&lt;/b&gt; property works for. When it is set to True, all the items will be transferred to the client side and the operations like sorting, paging, and filtering will be done in the client side.&lt;/br&gt;Hence, &quot;Loading...&quot; text is not shown while loading the data when the scrollbar scrolls.&lt;/br&gt;Otherwise, sorting, paging or filtering will be done at the server side, and sometimes &quot;Loading...&quot; text will be shown..
        /// </summary>
        internal static string DisableServerRead_Text1 {
            get {
                return ResourceManager.GetString("DisableServerRead_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to MultiRow without paging.
        /// </summary>
        internal static string DisableServerRead_Text2 {
            get {
                return ResourceManager.GetString("DisableServerRead_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Paging MultiRow which PageSize is set to 10.
        /// </summary>
        internal static string DisableServerRead_Text3 {
            get {
                return ResourceManager.GetString("DisableServerRead_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;MultiRow&lt;/b&gt; control has built-in support for Excel-like, fast, in-cell editing.&lt;/br&gt;There is no need to add extra columns with &apos;Edit&apos; buttons that switch&lt;/br&gt;between display and edit modes..
        /// </summary>
        internal static string Editing_Text0 {
            get {
                return ResourceManager.GetString("Editing_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Users can start editing simply by typing into any cell. This puts the cell in &apos;quick-edit&apos; mode.&lt;/br&gt;In this mode, pressing the cursor keys completes the editing and the grid moves the selection..
        /// </summary>
        internal static string Editing_Text1 {
            get {
                return ResourceManager.GetString("Editing_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Popup editing keeps the native editing enabled for quick Microsoft Excel-like data entry, and adds&lt;/br&gt;an &quot;Edit Detail&quot; button to invoke a form where the user can edit the item details..
        /// </summary>
        internal static string Editing_Text10 {
            get {
                return ResourceManager.GetString("Editing_Text10", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To see this in action, select an item on the grid and click the &quot;Edit Detail&quot; button above.&lt;/br&gt;This will bring up a form where users can edit the data for the currently selected item..
        /// </summary>
        internal static string Editing_Text11 {
            get {
                return ResourceManager.GetString("Editing_Text11", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The detail form uses specialized input controls that take up more space but can make data&lt;/br&gt;entry easier in some cases. The form has &quot;OK&quot; and &quot;Cancel&quot; buttons that commit the changes&lt;/br&gt;or restore the original data. Both actions are accomplished with a single call to the&lt;/br&gt;&lt;b&gt;CollectionView&lt;/b&gt; used as a data source for the grid..
        /// </summary>
        internal static string Editing_Text12 {
            get {
                return ResourceManager.GetString("Editing_Text12", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If for some reason you do not need the Microsoft Excel-style editing and prefer to add editing&lt;/br&gt;buttons to every row (typical of editable HTML tables), you can accomplish that by&lt;/br&gt;using &lt;b&gt;ItemFormatter&lt;/b&gt; and a few controller methods.&lt;/br&gt;To get the binding column in the ItemFormatter event handler, please use the MultiRow&apos;s&lt;/br&gt;&lt;b&gt;getBindingColumn&lt;/b&gt; function..
        /// </summary>
        internal static string Editing_Text13 {
            get {
                return ResourceManager.GetString("Editing_Text13", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The grid below demonstrates this approach. The buttons in the cells call the&lt;/br&gt;methods in the controller to perform the required actions:.
        /// </summary>
        internal static string Editing_Text14 {
            get {
                return ResourceManager.GetString("Editing_Text14", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Inline editing.
        /// </summary>
        internal static string Editing_Text15 {
            get {
                return ResourceManager.GetString("Editing_Text15", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Popup editing.
        /// </summary>
        internal static string Editing_Text16 {
            get {
                return ResourceManager.GetString("Editing_Text16", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Excel-Style editing.
        /// </summary>
        internal static string Editing_Text17 {
            get {
                return ResourceManager.GetString("Editing_Text17", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Editing.
        /// </summary>
        internal static string Editing_Text18 {
            get {
                return ResourceManager.GetString("Editing_Text18", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows how to edit cell data with various ways..
        /// </summary>
        internal static string Editing_Text19 {
            get {
                return ResourceManager.GetString("Editing_Text19", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Another way to begin in-cell editing is by pressing F2 or by clicking a cell twice.&lt;/br&gt;This puts the cell in &apos;full-edit&apos; mode. In this mode, the cursor keys move the caret within the cell text and the user must&lt;/br&gt;press the Enter, Tab, or Escape keys to complete editing..
        /// </summary>
        internal static string Editing_Text2 {
            get {
                return ResourceManager.GetString("Editing_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Edit Detail....
        /// </summary>
        internal static string Editing_Text20 {
            get {
                return ResourceManager.GetString("Editing_Text20", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to OK.
        /// </summary>
        internal static string Editing_Text21 {
            get {
                return ResourceManager.GetString("Editing_Text21", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Address.
        /// </summary>
        internal static string Editing_Text22 {
            get {
                return ResourceManager.GetString("Editing_Text22", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to City.
        /// </summary>
        internal static string Editing_Text23 {
            get {
                return ResourceManager.GetString("Editing_Text23", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Region.
        /// </summary>
        internal static string Editing_Text24 {
            get {
                return ResourceManager.GetString("Editing_Text24", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Country.
        /// </summary>
        internal static string Editing_Text25 {
            get {
                return ResourceManager.GetString("Editing_Text25", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Contact Title.
        /// </summary>
        internal static string Editing_Text26 {
            get {
                return ResourceManager.GetString("Editing_Text26", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Contact Name.
        /// </summary>
        internal static string Editing_Text27 {
            get {
                return ResourceManager.GetString("Editing_Text27", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Company Name.
        /// </summary>
        internal static string Editing_Text28 {
            get {
                return ResourceManager.GetString("Editing_Text28", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Supplier ID.
        /// </summary>
        internal static string Editing_Text29 {
            get {
                return ResourceManager.GetString("Editing_Text29", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Disable Editing&lt;/b&gt;&lt;/br&gt;You can disable editing at grid or column levels using the &lt;b&gt;isReadOnly&lt;/b&gt;&lt;/br&gt;property of grid or column objects..
        /// </summary>
        internal static string Editing_Text3 {
            get {
                return ResourceManager.GetString("Editing_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Edit Item.
        /// </summary>
        internal static string Editing_Text30 {
            get {
                return ResourceManager.GetString("Editing_Text30", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Mobile Devices:&lt;/b&gt;&lt;/br&gt;Mobile devices use the &lt;b&gt;double-click&lt;/b&gt; event to zoom in and out, and do not show&lt;/br&gt;keyboard by default. To start editing a cell on mobile devices, users need to simply click&lt;/br&gt;a cell to select it, then click it again to indicate they want to start editing..
        /// </summary>
        internal static string Editing_Text4 {
            get {
                return ResourceManager.GetString("Editing_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Automatic Type Validation/Coercion:&lt;/b&gt;&lt;/br&gt;If the user types anything that is invalid for a column (e.g. &quot;hello&quot; for a&lt;/br&gt;numeric or date column), the edits won&apos;t be applied and the cell will keep its&lt;/br&gt;original value. Dates and times are parsed using the format assigned to the&lt;/br&gt;column..
        /// </summary>
        internal static string Editing_Text5 {
            get {
                return ResourceManager.GetString("Editing_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Checkbox:&lt;/b&gt;&lt;/br&gt;By default (and unlike Microsoft Excel), Boolean values are shown as checkboxes. Users&lt;/br&gt;can change the checkbox values by clicking or by pressing the space bar.&lt;/br&gt;Checkboxes are easier to read and to edit than fields containing &quot;TRUE&quot; or&lt;/br&gt;&quot;FALSE&quot; strings..
        /// </summary>
        internal static string Editing_Text6 {
            get {
                return ResourceManager.GetString("Editing_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Update Modes:&lt;/b&gt;&lt;/br&gt;The edited data gets updated to the datasource server, by default, once editing is done.&lt;/br&gt;This is the normal update mode, for which users need to provide the Update, the Delete or the Create action url.&lt;/br&gt;And the corresponding codes used to update the datasource should be written in the corresponding action.&lt;/br&gt;However, users can also update, create or remove multiple items and commit them to the data source only once.&lt;/br&gt;This is the batch update mode, for which users need to [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string Editing_Text7 {
            get {
                return ResourceManager.GetString("Editing_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;input type=&quot;button&quot; value=&quot;Read More&quot; class=&quot;btn collapse in&quot; data-toggle=&quot;collapse&quot; data-target=&quot;.collapsed-content, .btn.collapse&quot; /&gt;.
        /// </summary>
        internal static string Editing_Text8 {
            get {
                return ResourceManager.GetString("Editing_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Here is a typical editable MultiRow:.
        /// </summary>
        internal static string Editing_Text9 {
            get {
                return ResourceManager.GetString("Editing_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Error..
        /// </summary>
        internal static string Error_Text0 {
            get {
                return ResourceManager.GetString("Error_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An error occurred while processing your request..
        /// </summary>
        internal static string Error_Text1 {
            get {
                return ResourceManager.GetString("Error_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The sample demonstrates how to export the contents of &lt;b&gt;MultiRow&lt;/b&gt; control to an Excel (xlsx) format..
        /// </summary>
        internal static string ExcelExport_Text0 {
            get {
                return ResourceManager.GetString("ExcelExport_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To export &lt;b&gt;MultiRow&lt;/b&gt; contents, pass the &lt;b&gt;MultiRow&lt;/b&gt; instance to the &lt;b&gt;FlexGridXlsxConverter.save&lt;/b&gt; method.&lt;/br&gt;This generates xlsx file content, which can be saved to a local file or sent to a server..
        /// </summary>
        internal static string ExcelExport_Text1 {
            get {
                return ResourceManager.GetString("ExcelExport_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Note:&lt;/b&gt; You must add a &lt;b&gt;jszip.js&lt;/b&gt; library to your application. Its CDN link is: &lt;a href=&quot;http://cdnjs.cloudflare.com/ajax/libs/jszip/2.2.1/jszip.min.js&quot;&gt;http://cdnjs.cloudflare.com/ajax/libs/jszip/2.2.1/jszip.min.js&lt;/a&gt;.
        /// </summary>
        internal static string ExcelExport_Text2 {
            get {
                return ResourceManager.GetString("ExcelExport_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows how to use filtering in the MultiRow control..
        /// </summary>
        internal static string Filter_Text0 {
            get {
                return ResourceManager.GetString("Filter_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows how to use frozen cells feature in the MultiRow control..
        /// </summary>
        internal static string Freezing_Text0 {
            get {
                return ResourceManager.GetString("Freezing_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;MultiRow&lt;/b&gt; control allows you to freeze rows and columns so they remain in view as the user scrolls the grid.&lt;/br&gt;Frozen cells can be edited and selected as regular cells, same as in Microsoft Excel and in the FlexGrid control..
        /// </summary>
        internal static string Freezing_Text1 {
            get {
                return ResourceManager.GetString("Freezing_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ~/Content/css/gcicons.css.
        /// </summary>
        internal static string GcIconsCssPath {
            get {
                return ResourceManager.GetString("GcIconsCssPath", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows how to use grouping support in the &lt;b&gt;MultiRow&lt;/b&gt; control. Most of the work is done by the CollectionView class, which is used as a data source for the grid.&lt;/br&gt;You can configure group description by &lt;b&gt;GroupBy&lt;/b&gt; method in view.&lt;/br&gt;To add grouping by Javascript, add one or more &lt;b&gt;GroupDescription&lt;/b&gt; objects to the &lt;b&gt;CollectionView.GroupDescriptions&lt;/b&gt; property.&lt;/br&gt;And ensure that the MultiRow&apos;s &lt;b&gt;ShowGroups&lt;/b&gt; property is set to true..
        /// </summary>
        internal static string Grouping_Text0 {
            get {
                return ResourceManager.GetString("Grouping_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can customize the text that is displayed in group header rows using the MultiRow&apos;s &lt;b&gt;GroupHeaderFormat&lt;/b&gt; property.&lt;/br&gt;By default, this displays the name of the group, for example, State, followed by the current group and the number of items in the group..
        /// </summary>
        internal static string Grouping_Text1 {
            get {
                return ResourceManager.GetString("Grouping_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The Group Panel feature allows you to add a drag-drop grouping UI to any MultiRow control..
        /// </summary>
        internal static string GroupPanel_Text0 {
            get {
                return ResourceManager.GetString("GroupPanel_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Traditional grid view, with one row per record.The user must scroll horizontally to see the whole record..
        /// </summary>
        internal static string Index_Text0 {
            get {
                return ResourceManager.GetString("Index_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This view uses two rows per record. The layout is divided into three groups: order, customer, and shipper..
        /// </summary>
        internal static string Index_Text1 {
            get {
                return ResourceManager.GetString("Index_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Here, the group spans three grid columns. It contains six cells with different spans.&lt;/br&gt;When generating the layout, the grid fits as many cells as possible in each row, and wraps to the next row when the group span is reached.&lt;/br&gt;The last cell in each row is automatically expanded to fill &lt;b&gt;Colspan&lt;/b&gt; of the group.&lt;/br&gt;The process is similar to wrapping of text to create a paragraph..
        /// </summary>
        internal static string Index_Text10 {
            get {
                return ResourceManager.GetString("Index_Text10", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The same process is applied to every group in the &lt;b&gt;LayoutDefinition&lt;/b&gt; object..
        /// </summary>
        internal static string Index_Text11 {
            get {
                return ResourceManager.GetString("Index_Text11", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LayoutDefinition.
        /// </summary>
        internal static string Index_Text12 {
            get {
                return ResourceManager.GetString("Index_Text12", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This view uses three rows per record. The layout is divided into three groups: order, customer, and shipper..
        /// </summary>
        internal static string Index_Text2 {
            get {
                return ResourceManager.GetString("Index_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The MultiRow control extends conventional grid layouts by using multiple rows to represent each data item..
        /// </summary>
        internal static string Index_Text3 {
            get {
                return ResourceManager.GetString("Index_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;MultiRow&lt;/b&gt; control extends conventional grid layouts by using multiple rows to represent each data item..
        /// </summary>
        internal static string Index_Text4 {
            get {
                return ResourceManager.GetString("Index_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;MultiRow&lt;/b&gt; control allows users to see and edit data in a tabular format, just like other conventional grids.&lt;/br&gt;However, &lt;b&gt;MultiRow&lt;/b&gt; is different from these grids in a way that it allows you to bind each data item to multiple rows,&lt;/br&gt;creating form-like interfaces that can display a large number of columns with minimal horizontal scrolling..
        /// </summary>
        internal static string Index_Text5 {
            get {
                return ResourceManager.GetString("Index_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;MultiRow&lt;/b&gt; control extends the &lt;b&gt;FlexGrid&lt;/b&gt; control, so if you know how to use &lt;b&gt;FlexGrid&lt;/b&gt;, you will be able to use &lt;b&gt;MultiRow&lt;/b&gt; in no time.&lt;/br&gt;The main new property is &lt;b&gt;LayoutDefinition&lt;/b&gt;, which takes an object that describes the layout of the grid rows and cells..
        /// </summary>
        internal static string Index_Text6 {
            get {
                return ResourceManager.GetString("Index_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;MultiRow&lt;/b&gt; control is not a simple replacement for conventional grids; it is a specialized tool that fits some particular scenarios really well..
        /// </summary>
        internal static string Index_Text7 {
            get {
                return ResourceManager.GetString("Index_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;LayoutDefinition&lt;/b&gt; property specifies the layout of cells in a grid.&lt;/br&gt;It contains a list of cell group objects. Each cell group specifies how many columns the group should span, and the cells that make up each group..
        /// </summary>
        internal static string Index_Text8 {
            get {
                return ResourceManager.GetString("Index_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The image below illustrates how a cell group is interpreted and turned into a grid layout:&lt;/br&gt;&lt;img src=&quot;~/Content/images/cellGroup.png&quot; /&gt;.
        /// </summary>
        internal static string Index_Text9 {
            get {
                return ResourceManager.GetString("Index_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows how to implement paged views with the &lt;b&gt;MultiRow&lt;/b&gt; control.&lt;/br&gt;All the work is done by the &lt;b&gt;CollectionView&lt;/b&gt; class, which is used as a data source for the grid.&lt;/br&gt;To enable paging, set the &lt;b&gt;PageSize&lt;/b&gt; property of &lt;b&gt;MultiRow&lt;/b&gt; or &lt;b&gt;CollectionViewService&lt;/b&gt;.&lt;/br&gt;To switch pages, use the &lt;b&gt;Pager&lt;/b&gt; control and set &lt;b&gt;Pager&lt;/b&gt;.&lt;b&gt;Owner&lt;/b&gt; property to the id of &lt;b&gt;MultiRow&lt;/b&gt; or &lt;b&gt;CollectionViewService&lt;/b&gt;..
        /// </summary>
        internal static string Paging_Text0 {
            get {
                return ResourceManager.GetString("Paging_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In this example, paging happens on server-side. This is because &lt;b&gt;CollectionView&lt;/b&gt; here acts like a service and synchronizes&lt;/br&gt;with server data. The &lt;b&gt;CollectionView&lt;/b&gt; internally does an ajax call to fetch next set of data. Refer @Html.ActionLink(&quot;Disable Server Reading&quot;, &quot;DisableServerRead&quot;) sample for client-side paging..
        /// </summary>
        internal static string Paging_Text1 {
            get {
                return ResourceManager.GetString("Paging_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Note:&lt;/b&gt; The paging UI is implemented outside the grid. This gives you complete&lt;/br&gt;control over the appearance and functionality of the paging mechanism.&lt;/br&gt;To customize the &lt;b&gt;Pager&lt;/b&gt; control by Javascript, refer the client &lt;b&gt;CollectionView&lt;/b&gt; class..
        /// </summary>
        internal static string Paging_Text2 {
            get {
                return ResourceManager.GetString("Paging_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can use the &lt;b&gt;FlexGridPdfConverter&lt;/b&gt;, a &lt;a href=&quot;https://github.com/devongovett/pdfkit&quot;&gt;PDFKit&lt;/a&gt;-based JavaScript library,&lt;/br&gt;to export the contents of &lt;b&gt;MultiRow&lt;/b&gt; control to PDF (Portable Document Format) without using any server-side code..
        /// </summary>
        internal static string PdfExport_Text0 {
            get {
                return ResourceManager.GetString("PdfExport_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To export the contents of &lt;b&gt;MultiRow&lt;/b&gt; control, you need to use the &lt;b&gt;FlexGridPdfConverter.export&lt;/b&gt; function that takes the following arguments:.
        /// </summary>
        internal static string PdfExport_Text1 {
            get {
                return ResourceManager.GetString("PdfExport_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;exportMode&lt;/b&gt;: Determines which part of the MultiRow control should be exported (all the data or only the current selection)..
        /// </summary>
        internal static string PdfExport_Text10 {
            get {
                return ResourceManager.GetString("PdfExport_Text10", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to embeddedFonts: Provides information to the export library about various custom fonts to be embedded, such as URL, name, style, weight..
        /// </summary>
        internal static string PdfExport_Text11 {
            get {
                return ResourceManager.GetString("PdfExport_Text11", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;styles&lt;/b&gt;: It is used to set up the style for the grid elements and link them with the embedded fonts..
        /// </summary>
        internal static string PdfExport_Text12 {
            get {
                return ResourceManager.GetString("PdfExport_Text12", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Export Settings:.
        /// </summary>
        internal static string PdfExport_Text13 {
            get {
                return ResourceManager.GetString("PdfExport_Text13", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample demonstrates how to export the contents of MultiRow to PDF (Portable Document Format) using the FlexGridPdfConverter, a PDFKit-based JavaScript library, without using any server-side code..
        /// </summary>
        internal static string PdfExport_Text14 {
            get {
                return ResourceManager.GetString("PdfExport_Text14", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In this sample, you can change the following export settings by using the menus below:.
        /// </summary>
        internal static string PdfExport_Text2 {
            get {
                return ResourceManager.GetString("PdfExport_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In this sample, &lt;b&gt;MultiRow&lt;/b&gt; uses font &lt;a href=&quot;https://github.com/mozilla/Fira&quot;&gt;Fira&lt;/a&gt; and two typefaces, &lt;b&gt;FiraSans-Regular.ttf&lt;/b&gt; and &lt;b&gt;FiraSans-Bold.ttf&lt;/b&gt;.&lt;/br&gt;The FiraSans-Bold.ttf (boldface) typeface is used to display the header cells, and the FiraSans-Regular.ttf typeface is used for the rest of the content..
        /// </summary>
        internal static string PdfExport_Text3 {
            get {
                return ResourceManager.GetString("PdfExport_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To embed the fonts in the PDF, the following export settings are used:.
        /// </summary>
        internal static string PdfExport_Text4 {
            get {
                return ResourceManager.GetString("PdfExport_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A MultiRow instance.
        /// </summary>
        internal static string PdfExport_Text5 {
            get {
                return ResourceManager.GetString("PdfExport_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name of the file to export.
        /// </summary>
        internal static string PdfExport_Text6 {
            get {
                return ResourceManager.GetString("PdfExport_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Export settings.
        /// </summary>
        internal static string PdfExport_Text7 {
            get {
                return ResourceManager.GetString("PdfExport_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;scaleMode&lt;/b&gt;: Determines how the MultiRow contents should be scaled in order to fit the page..
        /// </summary>
        internal static string PdfExport_Text8 {
            get {
                return ResourceManager.GetString("PdfExport_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;orientation&lt;/b&gt;: Determines the orientation of pages..
        /// </summary>
        internal static string PdfExport_Text9 {
            get {
                return ResourceManager.GetString("PdfExport_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows how you can bind MultiRow control to some data using Action..
        /// </summary>
        internal static string RemoteBind_Text0 {
            get {
                return ResourceManager.GetString("RemoteBind_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In this sample, you can sort the collection based on the corresponding field value chosen in the first list. 
        ///    You can also specify the sorting order in the second list..
        /// </summary>
        internal static string Sorting_Text0 {
            get {
                return ResourceManager.GetString("Sorting_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample demonstrates how to use sort feature in the MultiRow control..
        /// </summary>
        internal static string Sorting_Text1 {
            get {
                return ResourceManager.GetString("Sorting_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sorting Order :.
        /// </summary>
        internal static string Sorting_Text2 {
            get {
                return ResourceManager.GetString("Sorting_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sorting Field :.
        /// </summary>
        internal static string Sorting_Text3 {
            get {
                return ResourceManager.GetString("Sorting_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows how you can use built-in class names in CSS rules to customize the appearance of the record and group delimiters..
        /// </summary>
        internal static string Styling_Text0 {
            get {
                return ResourceManager.GetString("Styling_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In most of the applications, you would want to show where each record and group starts or ends.&lt;/br&gt;The &lt;b&gt;MultiRow&lt;/b&gt; control enables this by adding CSS class names to cell elements in the first and last row/column of each group.&lt;/br&gt;The class names are wj-record-start, wj-record-end, wj-group-start, and wj-group-end..
        /// </summary>
        internal static string Styling_Text1 {
            get {
                return ResourceManager.GetString("Styling_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This example shows how you can use these class names in CSS rules to customize the appearance of the record and group delimiters.&lt;/br&gt;It also shows how you can use the standard &lt;b&gt;CssClass&lt;/b&gt; property to customize the appearance of specific cells within groups..
        /// </summary>
        internal static string Styling_Text2 {
            get {
                return ResourceManager.GetString("Styling_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows how to use unobtrusive validation in the MultiRow control..
        /// </summary>
        internal static string UnobtrusiveValidation_Text0 {
            get {
                return ResourceManager.GetString("UnobtrusiveValidation_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The columns have the following validations:&lt;/br&gt;&lt;ul&gt;&lt;/br&gt;&lt;li&gt;&lt;b&gt;Name:&lt;/b&gt; Required. Alphanumeric and contains 4 to 10 characters.&lt;/li&gt;&lt;/br&gt;&lt;li&gt;&lt;b&gt;Industry:&lt;/b&gt; Required.&lt;/li&gt;&lt;/br&gt;&lt;li&gt;&lt;b&gt;Country:&lt;/b&gt; Required.&lt;/li&gt;&lt;/br&gt;&lt;li&gt;&lt;b&gt;Phone:&lt;/b&gt; Required. 8 to 11 characters.&lt;/li&gt;&lt;/br&gt;&lt;li&gt;&lt;b&gt;Email:&lt;/b&gt; Required. Valid e-mail address.&lt;/li&gt;&lt;/br&gt;&lt;li&gt;&lt;b&gt;Birthdate:&lt;/b&gt; Required.&lt;/li&gt;&lt;/br&gt;&lt;/ul&gt;.
        /// </summary>
        internal static string UnobtrusiveValidation_Text1 {
            get {
                return ResourceManager.GetString("UnobtrusiveValidation_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows how to make the MultiRow control work in virtual scrolling mode..
        /// </summary>
        internal static string VirtualScrolling_Text0 {
            get {
                return ResourceManager.GetString("VirtualScrolling_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To enable this functionality, the &lt;b&gt;DisableServerRead&lt;/b&gt; property should be set to false (default).&lt;/br&gt;Then the &lt;b&gt;InitialItemsCount&lt;/b&gt; property should be set to a number which is greater than 0..
        /// </summary>
        internal static string VirtualScrolling_Text1 {
            get {
                return ResourceManager.GetString("VirtualScrolling_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sample.
        /// </summary>
        internal static string _ControlLayout_Text0 {
            get {
                return ResourceManager.GetString("_ControlLayout_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Source.
        /// </summary>
        internal static string _ControlLayout_Text1 {
            get {
                return ResourceManager.GetString("_ControlLayout_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Documentation.
        /// </summary>
        internal static string _ControlLayout_Text2 {
            get {
                return ResourceManager.GetString("_ControlLayout_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Settings.
        /// </summary>
        internal static string _ControlLayout_Text3 {
            get {
                return ResourceManager.GetString("_ControlLayout_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Features.
        /// </summary>
        internal static string _ControlsNav_Text0 {
            get {
                return ResourceManager.GetString("_ControlsNav_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to GrapeCity, Inc. All Rights Reserved.&lt;br /&gt;&lt;/br&gt;All product and company names here in may be trademarks of their respective owners..
        /// </summary>
        internal static string _Layout_Text0 {
            get {
                return ResourceManager.GetString("_Layout_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ComponentOne.
        /// </summary>
        internal static string _Layout_Text1 {
            get {
                return ResourceManager.GetString("_Layout_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to MVC MultiRow Explorer.
        /// </summary>
        internal static string _Layout_Text2 {
            get {
                return ResourceManager.GetString("_Layout_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ASP.NET MVC Edition MultiRow Explorer.
        /// </summary>
        internal static string _Layout_Text3 {
            get {
                return ResourceManager.GetString("_Layout_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to https://www.grapecity.com/en/aspnet-mvc.
        /// </summary>
        internal static string _Layout_Text4 {
            get {
                return ResourceManager.GetString("_Layout_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to About.
        /// </summary>
        internal static string _SiteNav_Text0 {
            get {
                return ResourceManager.GetString("_SiteNav_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Support.
        /// </summary>
        internal static string _SiteNav_Text1 {
            get {
                return ResourceManager.GetString("_SiteNav_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Pricing.
        /// </summary>
        internal static string _SiteNav_Text2 {
            get {
                return ResourceManager.GetString("_SiteNav_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FREE TRIAL.
        /// </summary>
        internal static string _SiteNav_Text3 {
            get {
                return ResourceManager.GetString("_SiteNav_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Edit Theme &amp;gt;.
        /// </summary>
        internal static string _SiteNav_Text4 {
            get {
                return ResourceManager.GetString("_SiteNav_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to https://www.grapecity.com/en/aspnet-mvc.
        /// </summary>
        internal static string _SiteNav_Text5 {
            get {
                return ResourceManager.GetString("_SiteNav_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to http://supportone.componentone.com/login.
        /// </summary>
        internal static string _SiteNav_Text6 {
            get {
                return ResourceManager.GetString("_SiteNav_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to https://www.grapecity.com/en/pricing.
        /// </summary>
        internal static string _SiteNav_Text7 {
            get {
                return ResourceManager.GetString("_SiteNav_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to https://www.grapecity.com/en/download/componentone-studio.
        /// </summary>
        internal static string _SiteNav_Text8 {
            get {
                return ResourceManager.GetString("_SiteNav_Text8", resourceCulture);
            }
        }
    }
}
