//------------------------------------------------------------------------------
// <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 FlexGrid {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal FlexGrid() {
        }
        
        /// <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.FlexGrid", 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 Batch.
        /// </summary>
        internal static string BatchEditing_Batch {
            get {
                return ResourceManager.GetString("BatchEditing_Batch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Done..
        /// </summary>
        internal static string BatchEditing_Done {
            get {
                return ResourceManager.GetString("BatchEditing_Done", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No changes..
        /// </summary>
        internal static string BatchEditing_NoChanges {
            get {
                return ResourceManager.GetString("BatchEditing_NoChanges", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Normal.
        /// </summary>
        internal static string BatchEditing_Normal {
            get {
                return ResourceManager.GetString("BatchEditing_Normal", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Excel-Style editing:&lt;/b&gt;
        ///    The FlexGrid has built-in support for Excel-like, fast, in-cell editing.
        ///    There is no need to add extra columns with &apos;Edit&apos; buttons that switch
        ///    between display and edit modes.&lt;/p&gt;.
        /// </summary>
        internal static string BatchEditing_Text0 {
            get {
                return ResourceManager.GetString("BatchEditing_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Users can start editing simply by typing into any cell. This is called
        ///    &apos;quick-edit&apos; mode.
        ///    In this mode, the cursor keys finish the editing and the grid moves the selection.
        ///    They can also start editing by pressing F2 or by clicking a cell twice.
        ///    This is called &apos;full-edit&apos; mode.
        ///    In this mode, the cursor keys move the caret within the editor and the user must
        ///    press the Enter, Tab, or Escape keys to finish editing..
        /// </summary>
        internal static string BatchEditing_Text1 {
            get {
                return ResourceManager.GetString("BatchEditing_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to There are two modes for editing the data..
        /// </summary>
        internal static string BatchEditing_Text2 {
            get {
                return ResourceManager.GetString("BatchEditing_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In this mode, the item updated or created will be commit to the server after the corresponding row finishes editing. The removed row will be commit to the server immediately..
        /// </summary>
        internal static string BatchEditing_Text3 {
            get {
                return ResourceManager.GetString("BatchEditing_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If the user wants to update the data, the Update action Url should be provided. If he wants to add or remove the data, the Create or Delete action Url should be provided.
        ///    And the user should edit the data in the corresponding action. It is default mode..
        /// </summary>
        internal static string BatchEditing_Text4 {
            get {
                return ResourceManager.GetString("BatchEditing_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid has in-built support for BatchEditing, the user can update, create or remove multiple items and commit all changes to the data source once . The user can commit multiple modifications by sorting, paging or filtering the grid or simply on a button click..
        /// </summary>
        internal static string BatchEditing_Text5 {
            get {
                return ResourceManager.GetString("BatchEditing_Text5", 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_Text6 {
            get {
                return ResourceManager.GetString("BatchEditing_Text6", 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 DisableServerRead property of FlexGrid&apos;s ItemSource to True. This will enable client-side sorting, filtering, paging and data will only be submitted when the collectionView&apos;s  commit method is explicitly called from client-side..
        /// </summary>
        internal static string BatchEditing_Text7 {
            get {
                return ResourceManager.GetString("BatchEditing_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Update.
        /// </summary>
        internal static string BatchEditing_Update {
            get {
                return ResourceManager.GetString("BatchEditing_Update", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Updating....
        /// </summary>
        internal static string BatchEditing_Updating {
            get {
                return ResourceManager.GetString("BatchEditing_Updating", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid Country, Please use the country in the list[&quot;US&quot;, &quot;UK&quot;, &quot;Canada&quot;, &quot;Japan&quot;, &quot;China&quot;, &quot;France&quot;, &quot;German&quot;, &quot;Italy&quot;, &quot;Korea&quot;, &quot;Australia&quot;].
        /// </summary>
        internal static string BuiltInValidation_Message1 {
            get {
                return ResourceManager.GetString("BuiltInValidation_Message1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid Product, Please use the product in the list [&quot;Widget&quot;, &quot;Gadget&quot;, &quot;Doohickey&quot;].
        /// </summary>
        internal static string BuiltInValidation_Message2 {
            get {
                return ResourceManager.GetString("BuiltInValidation_Message2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot be less than 0 or greater than 5000!.
        /// </summary>
        internal static string BuiltInValidation_Message3 {
            get {
                return ResourceManager.GetString("BuiltInValidation_Message3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Active items are not allowed in the US or UK!.
        /// </summary>
        internal static string BuiltInValidation_Message4 {
            get {
                return ResourceManager.GetString("BuiltInValidation_Message4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows the basic usage of the built-in validation..
        /// </summary>
        internal static string BuiltInValidation_Text0 {
            get {
                return ResourceManager.GetString("BuiltInValidation_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Resize some columns and drag some to new positions..
        /// </summary>
        internal static string ColumnLayout_Li1 {
            get {
                return ResourceManager.GetString("ColumnLayout_Li1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Click the &quot;Save Column Layout&quot; button to save the changes to local storage..
        /// </summary>
        internal static string ColumnLayout_Li2 {
            get {
                return ResourceManager.GetString("ColumnLayout_Li2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Refresh the page to restore the original layout..
        /// </summary>
        internal static string ColumnLayout_Li3 {
            get {
                return ResourceManager.GetString("ColumnLayout_Li3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Click the &quot;Load Column Layout&quot; button to restore the layout from local storage..
        /// </summary>
        internal static string ColumnLayout_Li4 {
            get {
                return ResourceManager.GetString("ColumnLayout_Li4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Load Column Layout.
        /// </summary>
        internal static string ColumnLayout_LoadColumnLayout {
            get {
                return ResourceManager.GetString("ColumnLayout_LoadColumnLayout", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Save Column Layout.
        /// </summary>
        internal static string ColumnLayout_SaveColumnLayout {
            get {
                return ResourceManager.GetString("ColumnLayout_SaveColumnLayout", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The FlexGrid has a client columnLayout property that gets or sets a JSON string containing a list of grid columns and their properties.
        ///        It doesn&apos;t support the datamap column.
        ///        This sample uses the client columnLayout property to persist the column layout to the browser&apos;s localStorage. FlexGrid also supports server-side saving\loading of column layout,
        ///        this is helpful in cases where column layout maybe saved in a storage\database to present different users with different view. Pleas [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string ColumnLayout_Text0 {
            get {
                return ResourceManager.GetString("ColumnLayout_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To see how this works, follow these steps:.
        /// </summary>
        internal static string ColumnLayout_Text1 {
            get {
                return ResourceManager.GetString("ColumnLayout_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This view shows the FlexGrid control&apos;s custom cells features..
        /// </summary>
        internal static string CustomCells_Text0 {
            get {
                return ResourceManager.GetString("CustomCells_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows how you can use custom editors to change the values in
        ///        FlexGrid cells..
        /// </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 EditTemplate property to specify the column editor. 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 Use C1 Input controls which has &quot;Value&quot; or &quot;Text&quot; property..
        /// </summary>
        internal static string CustomEditors_Text10 {
            get {
                return ResourceManager.GetString("CustomEditors_Text10", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use other control or a C1 control which has NOT &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 Use grid&apos;s internal editor..
        /// </summary>
        internal static string CustomEditors_Text12 {
            get {
                return ResourceManager.GetString("CustomEditors_Text12", 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 only need set the EditTemplate property of a column..
        /// </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 set the editor&apos;s IsRequired to false.
        ///                If you want to the editor full 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;Start&quot;, &quot;End&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 listen the grid&apos;s OnClientCellEditEnding event and set
        ///                &lt;pre&gt;
        ///                     cellEditEndingEventArgs.cancel = true;
        ///                &lt;/pre&gt;
        ///                to apply your updating..
        /// </summary>
        internal static string CustomEditors_Text6 {
            get {
                return ResourceManager.GetString("CustomEditors_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Then you need consider when to update the cell value and remove the editor from a grid in your application.
        ///                For example, when the editor blurs, we need 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 &amp;lt;input /&amp;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 In this sample, &quot;Amount2&quot; and &quot;Active&quot; use grid internal editor. You don&apos;t need do anything..
        /// </summary>
        internal static string CustomEditors_Text9 {
            get {
                return ResourceManager.GetString("CustomEditors_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Country.
        /// </summary>
        internal static string CustomFooters_Country {
            get {
                return ResourceManager.GetString("CustomFooters_Country", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Column Footer Rows&lt;/b&gt;: In some situations you may want to display non-scrollable rows below
        ///            the grid data containing summary information such as subtotals.
        ///            This can be done by the &lt;b&gt;ShowColumnFooters(bool value = true, string rowHeaderText = null)&lt;/b&gt; method.
        ///            The grid will automatically provide values for any columns that have
        ///            the &lt;b&gt;Aggregate&lt;/b&gt; property set. This is what this sample does..
        /// </summary>
        internal static string CustomFooters_Li1 {
            get {
                return ResourceManager.GetString("CustomFooters_Li1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Group Footer Rows&lt;/b&gt;: When grouping is enabled, FlexGrid adds group rows above each group.
        ///            This sample shows how you can add custom group rows below each group as well..
        /// </summary>
        internal static string CustomFooters_Li2 {
            get {
                return ResourceManager.GetString("CustomFooters_Li2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to None.
        /// </summary>
        internal static string CustomFooters_None {
            get {
                return ResourceManager.GetString("CustomFooters_None", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Product.
        /// </summary>
        internal static string CustomFooters_Product {
            get {
                return ResourceManager.GetString("CustomFooters_Product", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Product and Color.
        /// </summary>
        internal static string CustomFooters_ProductAndColor {
            get {
                return ResourceManager.GetString("CustomFooters_ProductAndColor", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows how to extend FlexGrid to provide two types of footer elements..
        /// </summary>
        internal static string CustomFooters_Text0 {
            get {
                return ResourceManager.GetString("CustomFooters_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Select how to group the data.
        /// </summary>
        internal static string CustomFooters_Text1 {
            get {
                return ResourceManager.GetString("CustomFooters_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to See and edit the data here.
        /// </summary>
        internal static string CustomFooters_Text2 {
            get {
                return ResourceManager.GetString("CustomFooters_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Data Map.
        /// </summary>
        internal static string DataMap_DataMap {
            get {
                return ResourceManager.GetString("DataMap_DataMap", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Multi-column Data Map.
        /// </summary>
        internal static string DataMap_MultiColumnDataMap {
            get {
                return ResourceManager.GetString("DataMap_MultiColumnDataMap", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Data maps provide the grid with automatic look up capabilities. For example, you may want to display a customer name instead of his ID, or a color name instead of its RGB value.&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;
        ///    Columns with an associated data map 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 ShowDropDown property to false..
        /// </summary>
        internal static string DataMap_Text0 {
            get {
                return ResourceManager.GetString("DataMap_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &amp;nbsp;.
        /// </summary>
        internal static string DataMap_Text1 {
            get {
                return ResourceManager.GetString("DataMap_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;FlexGrid&lt;/b&gt; columns have a &lt;b&gt;DropDownCssClass&lt;/b&gt; property that can be used to
        ///    style 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, 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 Adding a row details section enables you to group some data in a template that is optionally visible or collapsed.&lt;br /&gt;
        ///    For example, you can add row details to a FlexGrid that presents only a summary of the data for each row, but presents more data when the user selects a row.&lt;br /&gt;
        ///    Also, you can set a callback function that determines whether a row has details..
        /// </summary>
        internal static string DetailRow_Text0 {
            get {
                return ResourceManager.GetString("DetailRow_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. Sorting, paging or filtering will be done in the client side.
        ///    And the text like &quot;Loading...&quot; is not shown for loading the data when the scrollbar scrolls.
        ///    Otherwise, sorting, paging or filtering will be done in server side. And sometimes the &quot;Loading...&quot; text will be shown..
        /// </summary>
        internal static string DisableServerRead_Text0 {
            get {
                return ResourceManager.GetString("DisableServerRead_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid without paging.
        /// </summary>
        internal static string DisableServerRead_Text1 {
            get {
                return ResourceManager.GetString("DisableServerRead_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Paging FlexGrid which PageSize is set to 10.
        /// </summary>
        internal static string DisableServerRead_Text2 {
            get {
                return ResourceManager.GetString("DisableServerRead_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cancel.
        /// </summary>
        internal static string Editing_Cancel {
            get {
                return ResourceManager.GetString("Editing_Cancel", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Category ID.
        /// </summary>
        internal static string Editing_CategoryID {
            get {
                return ResourceManager.GetString("Editing_CategoryID", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Category Name.
        /// </summary>
        internal static string Editing_CategoryName {
            get {
                return ResourceManager.GetString("Editing_CategoryName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Delete.
        /// </summary>
        internal static string Editing_Delete {
            get {
                return ResourceManager.GetString("Editing_Delete", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Description.
        /// </summary>
        internal static string Editing_Description {
            get {
                return ResourceManager.GetString("Editing_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Edit.
        /// </summary>
        internal static string Editing_Edit {
            get {
                return ResourceManager.GetString("Editing_Edit", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Edit Detail....
        /// </summary>
        internal static string Editing_EditDetail {
            get {
                return ResourceManager.GetString("Editing_EditDetail", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Editing.
        /// </summary>
        internal static string Editing_Editing {
            get {
                return ResourceManager.GetString("Editing_Editing", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Edit Item.
        /// </summary>
        internal static string Editing_EditItem {
            get {
                return ResourceManager.GetString("Editing_EditItem", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Excel-Style editing.
        /// </summary>
        internal static string Editing_ExcelStyleEditing {
            get {
                return ResourceManager.GetString("Editing_ExcelStyleEditing", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Inline editing.
        /// </summary>
        internal static string Editing_InlineEditing {
            get {
                return ResourceManager.GetString("Editing_InlineEditing", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to OK.
        /// </summary>
        internal static string Editing_OK {
            get {
                return ResourceManager.GetString("Editing_OK", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Popup editing.
        /// </summary>
        internal static string Editing_PopupEditing {
            get {
                return ResourceManager.GetString("Editing_PopupEditing", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Read More.
        /// </summary>
        internal static string Editing_ReadMore {
            get {
                return ResourceManager.GetString("Editing_ReadMore", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The FlexGrid has built-in support for Excel-like, fast, in-cell editing.
        ///    There is no need to add extra columns with &apos;Edit&apos; buttons that switch
        ///    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 is called
        ///    &apos;quick-edit&apos; mode.
        ///    In this mode, the cursor keys finish the editing and the grid moves the selection.
        ///    They can also start editing by pressing F2 or by clicking a cell twice.
        ///    This is called &apos;full-edit&apos; mode.
        ///    In this mode, the cursor keys move the caret within the editor and the user must
        ///    press the Enter, Tab, or Escape keys to finish editing..
        /// </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 Excel-like data entry, and adds
        ///    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 below.
        ///    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
        ///    entry easier in some cases. The form has &quot;OK&quot; and &quot;Cancel&quot; buttons that commit the changes
        ///    or restore the original data. Both actions are accomplished with a single call to the
        ///    &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 don&apos;t like the Excel-style editing and prefer to add editing
        ///    buttons to every row (typical of editable HTML tables), you can accomplish that
        ///    using a &lt;b&gt;cellFormatter&lt;/b&gt; and a few controller methods..
        /// </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
        ///    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 This sample shows how to edit cell data with various ways..
        /// </summary>
        internal static string Editing_Text15 {
            get {
                return ResourceManager.GetString("Editing_Text15", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can disable editing at the grid or column levels using the &lt;b&gt;isReadOnly&lt;/b&gt;
        ///        property of the grid or column objects..
        /// </summary>
        internal static string Editing_Text2 {
            get {
                return ResourceManager.GetString("Editing_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Mobile Devices:&lt;/b&gt;
        ///        Mobile devices use the double-click event to zoom in and out, and do not show
        ///        a keyboard by default. To start editing a cell on mobile devices, simply click
        ///        a cell to select it, then click it again to indicate you want to start editing..
        /// </summary>
        internal static string Editing_Text3 {
            get {
                return ResourceManager.GetString("Editing_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Automatic type Validation/Coercion:&lt;/b&gt;
        ///        If the user types anything that is invalid for the column (e.g. &quot;hello&quot; for a
        ///        numeric or date column), the edits won&apos;t be applied and the cell will keep its
        ///        original value. Dates and times are parsed using the format assigned to the
        ///        column..
        /// </summary>
        internal static string Editing_Text4 {
            get {
                return ResourceManager.GetString("Editing_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Checkboxes:&lt;/b&gt;
        ///        By default (and unlike Excel), Boolean values are shown as checkboxes. Users
        ///        can change the checkbox values by clicking or by pressing the space bar.
        ///        Checkboxes are easier to read and to edit than fields containing &quot;TRUE&quot; or
        ///        &quot;FALSE&quot; strings..
        /// </summary>
        internal static string Editing_Text5 {
            get {
                return ResourceManager.GetString("Editing_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Multiline:&lt;/b&gt;
        ///        When setting the column&apos;s &lt;b&gt;multiline&lt;/b&gt; property to true, the content of cells in
        ///        column would wrap at new line characters (\n). Like Excel, users can press ALT+ENTER to enter a new line..
        /// </summary>
        internal static string Editing_Text6 {
            get {
                return ResourceManager.GetString("Editing_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Editing Mode:&lt;/b&gt;
        ///        There are two modes for updating the data.
        ///        By default, the update operation will be commit to the server once finishing editing.
        ///        If the user wants to commit the update operation to datasource server, the Update, Delete or Create action url should be provided.
        ///        And the corresponding codes used to update the datasource should be written in the corresponding action.
        ///        The other mode is called BatchEdit. The user can update, create or remove multipl [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 Here is a typical editable grid, the Description column shows text in multiline..
        /// </summary>
        internal static string Editing_Text9 {
            get {
                return ResourceManager.GetString("Editing_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Export.
        /// </summary>
        internal static string ExcelImportExport_Export {
            get {
                return ResourceManager.GetString("ExcelImportExport_Export", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Import.
        /// </summary>
        internal static string ExcelImportExport_Import {
            get {
                return ResourceManager.GetString("ExcelImportExport_Import", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Include Column Headers.
        /// </summary>
        internal static string ExcelImportExport_IncludeColumnHeaders {
            get {
                return ResourceManager.GetString("ExcelImportExport_IncludeColumnHeaders", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The sample demonstrates how to export or import FlexGrid content to/from an Excel xlsx file..
        /// </summary>
        internal static string ExcelImportExport_Text0 {
            get {
                return ResourceManager.GetString("ExcelImportExport_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To export FlexGrid content, pass the FlexGrid instance to the &lt;b&gt;FlexGridXlsxConverter.save&lt;/b&gt; method. This generates xlsx file content, which can be saved to a local file or sent to a server..
        /// </summary>
        internal static string ExcelImportExport_Text1 {
            get {
                return ResourceManager.GetString("ExcelImportExport_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To populate FlexGrid with data from an xlsx file, pass the FlexGrid instance and the xlsx file content to the &lt;b&gt;FlexGridXlsxConverter.load&lt;/b&gt; method..
        /// </summary>
        internal static string ExcelImportExport_Text2 {
            get {
                return ResourceManager.GetString("ExcelImportExport_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Note:&lt;/b&gt;You should add jszip.js library by yourself and the CDN link is:http://cdnjs.cloudflare.com/ajax/libs/jszip/2.2.1/jszip.min.js.
        /// </summary>
        internal static string ExcelImportExport_Text3 {
            get {
                return ResourceManager.GetString("ExcelImportExport_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This view shows how to use filtering in FlexGrid..
        /// </summary>
        internal static string Filter_Text0 {
            get {
                return ResourceManager.GetString("Filter_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This view shows the FlexGrid control&apos;s frozen cells features..
        /// </summary>
        internal static string FrozenCells_Text0 {
            get {
                return ResourceManager.GetString("FrozenCells_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Customization.
        /// </summary>
        internal static string Globalization_Customization {
            get {
                return ResourceManager.GetString("Globalization_Customization", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Customize filter UI.
        /// </summary>
        internal static string Globalization_CustomizeFilterUI {
            get {
                return ResourceManager.GetString("Globalization_CustomizeFilterUI", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Globalization.
        /// </summary>
        internal static string Globalization_Globalization {
            get {
                return ResourceManager.GetString("Globalization_Globalization", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Please select a culture.
        /// </summary>
        internal static string Globalization_PleaseSelectACulture {
            get {
                return ResourceManager.GetString("Globalization_PleaseSelectACulture", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, MVC controls format and parse the data using American English culture.
        ///        The decimal symbol is a period, the thousand separator is a comma, and the days of
        ///        the week are &quot;Sunday&quot; through &quot;Saturday&quot;..
        /// </summary>
        internal static string Globalization_Text0 {
            get {
                return ResourceManager.GetString("Globalization_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If your application targets other cultures, register the appropriate culture by
        ///        registering the MVC scripts in your HTML pages..
        /// </summary>
        internal static string Globalization_Text1 {
            get {
                return ResourceManager.GetString("Globalization_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, to localize an application for the German culture, register the &quot;de&quot;
        ///        culture while registering the scripts:.
        /// </summary>
        internal static string Globalization_Text2 {
            get {
                return ResourceManager.GetString("Globalization_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The client &lt;b&gt;FlexGridFilter&lt;/b&gt; class is localizable, and you can take advantage
        ///        of this feature for modifying the UI strings and also the lists of conditions and
        ///        operators..
        /// </summary>
        internal static string Globalization_Text3 {
            get {
                return ResourceManager.GetString("Globalization_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In this sample, we customized the list of operators by assigning custom arrays to
        ///        the filter&apos;s &lt;b&gt;stringOperators&lt;/b&gt;, &lt;b&gt;numberOperators&lt;/b&gt;, &lt;b&gt;dateOperators&lt;/b&gt;,
        ///        &lt;b&gt;and booleanOperators&lt;/b&gt;..
        /// </summary>
        internal static string Globalization_Text4 {
            get {
                return ResourceManager.GetString("Globalization_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This view shows how to localize the FlexGrid control..
        /// </summary>
        internal static string Globalization_Text5 {
            get {
                return ResourceManager.GetString("Globalization_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows grouping support in the FlexGrid. Most of the work is
        ///        done by the CollectionView class used as a data source for the grid.
        ///        You can config group description by GroupBy method in view.
        ///        To add grouping by Javascript, add one or more GroupDescription
        ///        objects to the collectionView.groupDescriptions property. And ensure
        ///        that the grid&apos;s showGroups 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 grid&apos;s groupHeaderFormat property. By default, this displays the name
        ///        of the group, for example, ShipCountry, followed by the current group and the
        ///        number of items in the group. Use the format property on each Column object
        ///        to format aggregated data displayed in the group header for that column.
        ///        Notice how we use the column&apos;s aggregate property to specify how to aggregate
        ///        the dat [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string Grouping_Text1 {
            get {
                return ResourceManager.GetString("Grouping_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Drag columns here to create Groups.
        /// </summary>
        internal static string GroupPanel_Placeholder1 {
            get {
                return ResourceManager.GetString("GroupPanel_Placeholder1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Drag columns here....
        /// </summary>
        internal static string GroupPanel_Placeholder2 {
            get {
                return ResourceManager.GetString("GroupPanel_Placeholder2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The GroupPanel feature allows you to add a drag-drop grouping UI to any FlexGrid control..
        /// </summary>
        internal static string GroupPanel_Text0 {
            get {
                return ResourceManager.GetString("GroupPanel_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This view shows basic features of FlexGrid for ASP.NET MVC..
        /// </summary>
        internal static string Index_Text0 {
            get {
                return ResourceManager.GetString("Index_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid for ASP.NET MVC is new version of the FlexGrid control, which is more flexible and powerful than ever.
        ///    This grid allows you to select, edit, sort, group, filter and page data. Additionally, this versatile FlexGrid control lets you format
        ///    data and easily visualize the hierarchical data. Performance is a vital attribute of FlexGrid, therefore, the core control is
        ///    lightweight and fast. For complex features the control uses extensions..
        /// </summary>
        internal static string Index_Text1 {
            get {
                return ResourceManager.GetString("Index_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The client side CollectionView has built-in support for currency, which enables you to implement master-detail scenarios with FlexGrid. You can refer to the &lt;strong&gt;currentItem&lt;/strong&gt; and use it as a binding source for any elements on the page.
        ///&lt;br/&gt;
        ///Note that you have to update the details view when the current item changes. To do that, attach a handler to the &lt;strong&gt;currentChanged&lt;/strong&gt; event and update the details view as needed..
        /// </summary>
        internal static string MasterDetail_Text0 {
            get {
                return ResourceManager.GetString("MasterDetail_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Customers:.
        /// </summary>
        internal static string MasterDetail_Text1 {
            get {
                return ResourceManager.GetString("MasterDetail_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to All orders of the selected Customer:.
        /// </summary>
        internal static string MasterDetail_Text2 {
            get {
                return ResourceManager.GetString("MasterDetail_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This view shows the FlexGrid control&apos;s merge cells features..
        /// </summary>
        internal static string MergeCells_Text0 {
            get {
                return ResourceManager.GetString("MergeCells_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This example shows how you can bind FlexGrid with an OData service..
        /// </summary>
        internal static string ODataBind_Text0 {
            get {
                return ResourceManager.GetString("ODataBind_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows how to implement paged views with the FlexGrid.
        ///        All the work is done by the CollectionView class used as a data source for the grid.
        ///        To enable paging, set the PageSize property of &lt;b&gt;FlexGrid&lt;/b&gt; or &lt;b&gt;CollectionViewService&lt;/b&gt;.
        ///        To switch pages, use the Pager Control and set Pager.Owner property to the id of &lt;b&gt;FlexGrid&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, the paging happens server-side. This is because CollectionView here acts like a service and synchronizes
        ///        with server data. The CollectionView internally does an ajax call to fetch next set of data. Refer Disable Server Reading 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; That the paging UI is implemented outside of the grid. This gives you complete
        ///        control over the appearance and functionality of the paging mechanism.
        ///        To customize the Pager by Javascript, please refer the client CollectionView class..
        /// </summary>
        internal static string Paging_Text2 {
            get {
                return ResourceManager.GetString("Paging_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Allow Merging.
        /// </summary>
        internal static string PDFExport_AllowMerging {
            get {
                return ResourceManager.GetString("PDFExport_AllowMerging", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Export.
        /// </summary>
        internal static string PDFExport_Export {
            get {
                return ResourceManager.GetString("PDFExport_Export", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Export Mode.
        /// </summary>
        internal static string PDFExport_ExportMode {
            get {
                return ResourceManager.GetString("PDFExport_ExportMode", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Export Settings:.
        /// </summary>
        internal static string PDFExport_ExportSettings {
            get {
                return ResourceManager.GetString("PDFExport_ExportSettings", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;embeddedFonts&lt;/b&gt;: Provides information to the export library, about various custom fonts to be embedded, such as URL,
        ///                name, style, weight..
        /// </summary>
        internal static string PDFExport_Li1 {
            get {
                return ResourceManager.GetString("PDFExport_Li1", 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_Li2 {
            get {
                return ResourceManager.GetString("PDFExport_Li2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Export settings..
        /// </summary>
        internal static string PDFExport_Li3 {
            get {
                return ResourceManager.GetString("PDFExport_Li3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;scaleMode&lt;/b&gt;: Determines how the FlexGrid content should be scaled in order to fit the page..
        /// </summary>
        internal static string PDFExport_Li4 {
            get {
                return ResourceManager.GetString("PDFExport_Li4", 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_Li5 {
            get {
                return ResourceManager.GetString("PDFExport_Li5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;exportMode&lt;/b&gt;: Determines which part of the FlexGrid should be exported (all of the data or only the current selection)..
        /// </summary>
        internal static string PDFExport_Li6 {
            get {
                return ResourceManager.GetString("PDFExport_Li6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Orientation.
        /// </summary>
        internal static string PDFExport_Orientation {
            get {
                return ResourceManager.GetString("PDFExport_Orientation", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Scale Mode.
        /// </summary>
        internal static string PDFExport_ScaleMode {
            get {
                return ResourceManager.GetString("PDFExport_ScaleMode", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can use the FlexGridPdfConverter, a &lt;a href=&quot;https://github.com/devongovett/pdfkit&quot;&gt;PDFKit&lt;/a&gt;-based JavaScript library,
        ///        to export FlexGrid 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 a FlexGrid, 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 In this sample, you can change the following export settings using the menus above:.
        /// </summary>
        internal static string PDFExport_Text2 {
            get {
                return ResourceManager.GetString("PDFExport_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows how the row grouping feature of the FlexGrid is supported in the FlexGridPdfConverter..
        /// </summary>
        internal static string PDFExport_Text3 {
            get {
                return ResourceManager.GetString("PDFExport_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows how the cell merging feature of the FlexGrid is supported in the FlexGridPdfConverter..
        /// </summary>
        internal static string PDFExport_Text4 {
            get {
                return ResourceManager.GetString("PDFExport_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows how the tree view feature of the FlexGrid is supported in the FlexGridPdfConverter..
        /// </summary>
        internal static string PDFExport_Text5 {
            get {
                return ResourceManager.GetString("PDFExport_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In this sample, FlexGrid 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;, are embeded into the document.
        ///            The FiraSans-Bold.ttf (boldface) typeface is used to display the header cells, and the FiraSans-Regular.ttf
        ///            typeface is used for rest of the content..
        /// </summary>
        internal static string PDFExport_Text6 {
            get {
                return ResourceManager.GetString("PDFExport_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To achieve this, the following export settings are used:.
        /// </summary>
        internal static string PDFExport_Text7 {
            get {
                return ResourceManager.GetString("PDFExport_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Grouping support.
        /// </summary>
        internal static string PDFExport_Title1 {
            get {
                return ResourceManager.GetString("PDFExport_Title1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Merging support.
        /// </summary>
        internal static string PDFExport_Title2 {
            get {
                return ResourceManager.GetString("PDFExport_Title2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tree view support and font embedding.
        /// </summary>
        internal static string PDFExport_Title3 {
            get {
                return ResourceManager.GetString("PDFExport_Title3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This example shows how you can bind FlexGrid with the data from some Action..
        /// </summary>
        internal static string RemoteBind_Text0 {
            get {
                return ResourceManager.GetString("RemoteBind_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Right To Left.
        /// </summary>
        internal static string RightToLeft_RightToLeft {
            get {
                return ResourceManager.GetString("RightToLeft_RightToLeft", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Some languages (Arabic and Hebrew especially) render content from the right
        ///    to the left of the page. HTML accommodates this with the &apos;dir&apos; attribute.
        ///    Setting &apos;dir&apos; to &apos;rtl&apos; on any element causes the element&apos;s content to flow 
        ///    from right to left..
        /// </summary>
        internal static string RightToLeft_Text0 {
            get {
                return ResourceManager.GetString("RightToLeft_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;FlexGrid&lt;/b&gt; supports this automatically. If the element hosting the
        ///    grid has the &apos;dir&apos; attribute set to &apos;rtl&apos;, the grid will render columns 
        ///    from the right to the left. You don&apos;t have to set any properties on the 
        ///    control..
        /// </summary>
        internal static string RightToLeft_Text1 {
            get {
                return ResourceManager.GetString("RightToLeft_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Note that the &apos;dir&apos; attribute value is inherited, so if you set it on the
        ///    body tag for example, the entire page will be rendered from right to left,
        ///    including the grid..
        /// </summary>
        internal static string RightToLeft_Text2 {
            get {
                return ResourceManager.GetString("RightToLeft_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Note also that CSS has a &apos;direction&apos; attribute that performs the same 
        ///    function as the &apos;dir&apos; element attribute. The &apos;dir&apos; attribute is generally
        ///    considered more appropriate for 
        ///    &lt;a href=&quot;http://www.w3.org/International/questions/qa-bidi-css-markup&quot;&gt;several reasons&lt;/a&gt;,
        ///    including the fact that the &apos;dir&apos; attribute can be used in CSS rules..
        /// </summary>
        internal static string RightToLeft_Text3 {
            get {
                return ResourceManager.GetString("RightToLeft_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sorting Field.
        /// </summary>
        internal static string Sorting_SortingField {
            get {
                return ResourceManager.GetString("Sorting_SortingField", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sorting Order.
        /// </summary>
        internal static string Sorting_SortingOrder {
            get {
                return ResourceManager.GetString("Sorting_SortingOrder", 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 Example 1:.
        /// </summary>
        internal static string StarSizing_Example1 {
            get {
                return ResourceManager.GetString("StarSizing_Example1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Example 2:.
        /// </summary>
        internal static string StarSizing_Example2 {
            get {
                return ResourceManager.GetString("StarSizing_Example2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Example 3:.
        /// </summary>
        internal static string StarSizing_Example3 {
            get {
                return ResourceManager.GetString("StarSizing_Example3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This grid has four columns. The first is 80 pixels wide and can be resized between
        ///        40 and 160 pixels. The other three have widths of 2*, *, and *, and cannot be
        ///        resized using the mouse..
        /// </summary>
        internal static string StarSizing_Text0 {
            get {
                return ResourceManager.GetString("StarSizing_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Notice that the second column is twice as wide as the third and fourth columns, and that
        ///        they keep these proportions even as you resize the first column or the whole grid..
        /// </summary>
        internal static string StarSizing_Text1 {
            get {
                return ResourceManager.GetString("StarSizing_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This grid shows how you can make any column stretch to fill the available space. In this case,
        ///        we set the width of the second column to * to achieve that effect..
        /// </summary>
        internal static string StarSizing_Text2 {
            get {
                return ResourceManager.GetString("StarSizing_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to We also set the minimum width of the second column to 100 pixels in order to prevent it from
        ///        getting too narrow when the other columns in the grid are resized, and we prevent users from 
        ///        resizing this column with the mouse..
        /// </summary>
        internal static string StarSizing_Text3 {
            get {
                return ResourceManager.GetString("StarSizing_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This example sets all widths to *, which means the space available is divided equally among them.
        ///        Resize the browser and notice how the grid resizes and the columns fill it up equally..
        /// </summary>
        internal static string StarSizing_Text4 {
            get {
                return ResourceManager.GetString("StarSizing_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Also, unlike the other examples, this one sets the allowResizing property of the entire grid rather 
        ///        than an individual column. We set this one to None, but you may also choose Columns, Rows, or Both..
        /// </summary>
        internal static string StarSizing_Text5 {
            get {
                return ResourceManager.GetString("StarSizing_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows how you can use XAML-style star sizing to implement flexible layouts
        ///    with the FlexGrid. Star sizing is specified in the width property of the object..
        /// </summary>
        internal static string StarSizing_Text6 {
            get {
                return ResourceManager.GetString("StarSizing_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The file structure of this sample project.
        /// </summary>
        internal static string TreeView_Text0 {
            get {
                return ResourceManager.GetString("TreeView_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows how to use FlexGrid to display a tree view..
        /// </summary>
        internal static string TreeView_Text1 {
            get {
                return ResourceManager.GetString("TreeView_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Name:&lt;/b&gt; Required. Alphanumeric and contains 4 to 10 characters..
        /// </summary>
        internal static string UnobtrusiveValidation_Li1 {
            get {
                return ResourceManager.GetString("UnobtrusiveValidation_Li1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Industry:&lt;/b&gt; Required..
        /// </summary>
        internal static string UnobtrusiveValidation_Li2 {
            get {
                return ResourceManager.GetString("UnobtrusiveValidation_Li2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Country:&lt;/b&gt; Required..
        /// </summary>
        internal static string UnobtrusiveValidation_Li3 {
            get {
                return ResourceManager.GetString("UnobtrusiveValidation_Li3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Phone:&lt;/b&gt; Required. 8 to 11 characters..
        /// </summary>
        internal static string UnobtrusiveValidation_Li4 {
            get {
                return ResourceManager.GetString("UnobtrusiveValidation_Li4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Email:&lt;/b&gt; Required. Valid e-mail address..
        /// </summary>
        internal static string UnobtrusiveValidation_Li5 {
            get {
                return ResourceManager.GetString("UnobtrusiveValidation_Li5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Birthdate:&lt;/b&gt; Required..
        /// </summary>
        internal static string UnobtrusiveValidation_Li6 {
            get {
                return ResourceManager.GetString("UnobtrusiveValidation_Li6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows the basic usage of the unobtrusive validation..
        /// </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:.
        /// </summary>
        internal static string UnobtrusiveValidation_Text1 {
            get {
                return ResourceManager.GetString("UnobtrusiveValidation_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows the basic usage of the unobtrusive validation..
        /// </summary>
        internal static string UnobtrusiveValidation_Text2 {
            get {
                return ResourceManager.GetString("UnobtrusiveValidation_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows how to make grid work in virtual scrolling mode. To enable this functionality, the DisableServerRead property should be false(default). Then the InitialItemsCount property should be set a number which is greater than 0..
        /// </summary>
        internal static string VirtualScrolling_Text0 {
            get {
                return ResourceManager.GetString("VirtualScrolling_Text0", resourceCulture);
            }
        }
    }
}
