//===============================================================================
// Microsoft patterns & practices Enterprise Library
// Validation Application Block
//===============================================================================
// Copyright © Microsoft Corporation.  All rights reserved.
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY
// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT
// LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
// FITNESS FOR A PARTICULAR PURPOSE.
//===============================================================================

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

namespace Microsoft.Practices.EnterpriseLibrary.Validation.Configuration {
    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 your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "2.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class DesignResources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal DesignResources() {
        }
        
        /// <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("Microsoft.Practices.EnterpriseLibrary.Validation.Configuration.DesignResources", typeof(DesignResources).Assembly);
                    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 Add Validation Settings.
        /// </summary>
        internal static string AddValidationSettings {
            get {
                return ResourceManager.GetString("AddValidationSettings", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Provides the capability to create complex validation rules using a hierarchy of nested validators. 
        ///This validator returns True only when all validators it contains return True for the validated type..
        /// </summary>
        internal static string AndCompositeValidatorDataDescription {
            get {
                return ResourceManager.GetString("AndCompositeValidatorDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to And Composite Validator.
        /// </summary>
        internal static string AndCompositeValidatorDataDisplayName {
            get {
                return ResourceManager.GetString("AndCompositeValidatorDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The template to use when creating the validation message. 
        ///The template can contain placeholders for values exposed by the individual validation results for each member of the validated type. .
        /// </summary>
        internal static string AndCompositeValidatorDataMessageTemplateDescription {
            get {
                return ResourceManager.GetString("AndCompositeValidatorDataMessageTemplateDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Message Template.
        /// </summary>
        internal static string AndCompositeValidatorDataMessageTemplateDisplayName {
            get {
                return ResourceManager.GetString("AndCompositeValidatorDataMessageTemplateDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The key in an external resource file for the localized string to use as the validation message. .
        /// </summary>
        internal static string AndCompositeValidatorDataMessageTemplateResourceNameDescription {
            get {
                return ResourceManager.GetString("AndCompositeValidatorDataMessageTemplateResourceNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Name.
        /// </summary>
        internal static string AndCompositeValidatorDataMessageTemplateResourceNameDisplayName {
            get {
                return ResourceManager.GetString("AndCompositeValidatorDataMessageTemplateResourceNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type of the external resource file containing the localized string to use as the validation message. .
        /// </summary>
        internal static string AndCompositeValidatorDataMessageTemplateResourceTypeNameDescription {
            get {
                return ResourceManager.GetString("AndCompositeValidatorDataMessageTemplateResourceTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Type.
        /// </summary>
        internal static string AndCompositeValidatorDataMessageTemplateResourceTypeNameDisplayName {
            get {
                return ResourceManager.GetString("AndCompositeValidatorDataMessageTemplateResourceTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the And Composite Validator..
        /// </summary>
        internal static string AndCompositeValidatorDataNameDescription {
            get {
                return ResourceManager.GetString("AndCompositeValidatorDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string AndCompositeValidatorDataNameDisplayName {
            get {
                return ResourceManager.GetString("AndCompositeValidatorDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A user-supplied string value that can be used to identify or classify the validator. 
        ///It can be accessed from code, and is typically used to sort or categorize the validation results. .
        /// </summary>
        internal static string AndCompositeValidatorDataTagDescription {
            get {
                return ResourceManager.GetString("AndCompositeValidatorDataTagDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tag.
        /// </summary>
        internal static string AndCompositeValidatorDataTagDisplayName {
            get {
                return ResourceManager.GetString("AndCompositeValidatorDataTagDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the And Composite Validator..
        /// </summary>
        internal static string AndCompositeValidatorDataTypeNameDescription {
            get {
                return ResourceManager.GetString("AndCompositeValidatorDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string AndCompositeValidatorDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("AndCompositeValidatorDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collection of validators nested within this validator, which must all return True for this validator to return True..
        /// </summary>
        internal static string AndCompositeValidatorDataValidatorsDescription {
            get {
                return ResourceManager.GetString("AndCompositeValidatorDataValidatorsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Validators.
        /// </summary>
        internal static string AndCompositeValidatorDataValidatorsDisplayName {
            get {
                return ResourceManager.GetString("AndCompositeValidatorDataValidatorsDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The set of characters that may or must occur in the string to be validated..
        /// </summary>
        internal static string ContainsCharactersValidatorDataCharacterSetDescription {
            get {
                return ResourceManager.GetString("ContainsCharactersValidatorDataCharacterSetDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Character Set.
        /// </summary>
        internal static string ContainsCharactersValidatorDataCharacterSetDisplayName {
            get {
                return ResourceManager.GetString("ContainsCharactersValidatorDataCharacterSetDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Determines how the validator checks for characters. 
        ///&apos;Any&apos; (the default) means the value will be valid if it contains any of the characters defined for the Character Set. 
        ///&apos;All&apos; means that the value must contain all of the characters defined for the Character Set..
        /// </summary>
        internal static string ContainsCharactersValidatorDataContainsCharactersDescription {
            get {
                return ResourceManager.GetString("ContainsCharactersValidatorDataContainsCharactersDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Contains Characters.
        /// </summary>
        internal static string ContainsCharactersValidatorDataContainsCharactersDisplayName {
            get {
                return ResourceManager.GetString("ContainsCharactersValidatorDataContainsCharactersDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A validator that checks if a string value contains any or all of the characters specified for the Character Set property..
        /// </summary>
        internal static string ContainsCharactersValidatorDataDescription {
            get {
                return ResourceManager.GetString("ContainsCharactersValidatorDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Contains Characters Validator.
        /// </summary>
        internal static string ContainsCharactersValidatorDataDisplayName {
            get {
                return ResourceManager.GetString("ContainsCharactersValidatorDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The template to use when creating the validation message. 
        ///The template can contain placeholders for values exposed by the individual validation results for each member of the validated type. .
        /// </summary>
        internal static string ContainsCharactersValidatorDataMessageTemplateDescription {
            get {
                return ResourceManager.GetString("ContainsCharactersValidatorDataMessageTemplateDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Message Template.
        /// </summary>
        internal static string ContainsCharactersValidatorDataMessageTemplateDisplayName {
            get {
                return ResourceManager.GetString("ContainsCharactersValidatorDataMessageTemplateDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The key in an external resource file for the localized string to use as the validation message. .
        /// </summary>
        internal static string ContainsCharactersValidatorDataMessageTemplateResourceNameDescription {
            get {
                return ResourceManager.GetString("ContainsCharactersValidatorDataMessageTemplateResourceNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Name.
        /// </summary>
        internal static string ContainsCharactersValidatorDataMessageTemplateResourceNameDisplayName {
            get {
                return ResourceManager.GetString("ContainsCharactersValidatorDataMessageTemplateResourceNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type of the external resource file containing the localized string to use as the validation message. .
        /// </summary>
        internal static string ContainsCharactersValidatorDataMessageTemplateResourceTypeNameDescription {
            get {
                return ResourceManager.GetString("ContainsCharactersValidatorDataMessageTemplateResourceTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Type.
        /// </summary>
        internal static string ContainsCharactersValidatorDataMessageTemplateResourceTypeNameDisplayName {
            get {
                return ResourceManager.GetString("ContainsCharactersValidatorDataMessageTemplateResourceTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Contains Characters Validator..
        /// </summary>
        internal static string ContainsCharactersValidatorDataNameDescription {
            get {
                return ResourceManager.GetString("ContainsCharactersValidatorDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string ContainsCharactersValidatorDataNameDisplayName {
            get {
                return ResourceManager.GetString("ContainsCharactersValidatorDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Reverses the validation behavior. 
        ///When set to True, validation will fail (the validator will return False) if the validation rules are satisfied, instead of the default behavior of failing when they are not satisfied. 
        ///The default is False..
        /// </summary>
        internal static string ContainsCharactersValidatorDataNegatedDescription {
            get {
                return ResourceManager.GetString("ContainsCharactersValidatorDataNegatedDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Negated.
        /// </summary>
        internal static string ContainsCharactersValidatorDataNegatedDisplayName {
            get {
                return ResourceManager.GetString("ContainsCharactersValidatorDataNegatedDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A user-supplied string value that can be used to identify or classify the validator. 
        ///It can be accessed from code, and is typically used to sort or categorize the validation results. .
        /// </summary>
        internal static string ContainsCharactersValidatorDataTagDescription {
            get {
                return ResourceManager.GetString("ContainsCharactersValidatorDataTagDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tag.
        /// </summary>
        internal static string ContainsCharactersValidatorDataTagDisplayName {
            get {
                return ResourceManager.GetString("ContainsCharactersValidatorDataTagDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Contains Characters Validator..
        /// </summary>
        internal static string ContainsCharactersValidatorDataTypeNameDescription {
            get {
                return ResourceManager.GetString("ContainsCharactersValidatorDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string ContainsCharactersValidatorDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("ContainsCharactersValidatorDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Validator (using type picker).
        /// </summary>
        internal static string CustomValidatorDataAddCommand {
            get {
                return ResourceManager.GetString("CustomValidatorDataAddCommand", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom implementation of a Validator, added to the Validation Application Block..
        /// </summary>
        internal static string CustomValidatorDataDescription {
            get {
                return ResourceManager.GetString("CustomValidatorDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Validator.
        /// </summary>
        internal static string CustomValidatorDataDisplayName {
            get {
                return ResourceManager.GetString("CustomValidatorDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The template to use when creating the validation message. 
        ///The template can contain placeholders for values exposed by the individual validation results for each member of the validated type. .
        /// </summary>
        internal static string CustomValidatorDataMessageTemplateDescription {
            get {
                return ResourceManager.GetString("CustomValidatorDataMessageTemplateDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Message Template.
        /// </summary>
        internal static string CustomValidatorDataMessageTemplateDisplayName {
            get {
                return ResourceManager.GetString("CustomValidatorDataMessageTemplateDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The key in an external resource file for the localized string to use as the validation message. .
        /// </summary>
        internal static string CustomValidatorDataMessageTemplateResourceNameDescription {
            get {
                return ResourceManager.GetString("CustomValidatorDataMessageTemplateResourceNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Name.
        /// </summary>
        internal static string CustomValidatorDataMessageTemplateResourceNameDisplayName {
            get {
                return ResourceManager.GetString("CustomValidatorDataMessageTemplateResourceNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type of the external resource file containing the localized string to use as the validation message. .
        /// </summary>
        internal static string CustomValidatorDataMessageTemplateResourceTypeNameDescription {
            get {
                return ResourceManager.GetString("CustomValidatorDataMessageTemplateResourceTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Type.
        /// </summary>
        internal static string CustomValidatorDataMessageTemplateResourceTypeNameDisplayName {
            get {
                return ResourceManager.GetString("CustomValidatorDataMessageTemplateResourceTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Custom Validator..
        /// </summary>
        internal static string CustomValidatorDataNameDescription {
            get {
                return ResourceManager.GetString("CustomValidatorDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string CustomValidatorDataNameDisplayName {
            get {
                return ResourceManager.GetString("CustomValidatorDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A user-supplied string value that can be used to identify or classify the validator. 
        ///It can be accessed from code, and is typically used to sort or categorize the validation results. .
        /// </summary>
        internal static string CustomValidatorDataTagDescription {
            get {
                return ResourceManager.GetString("CustomValidatorDataTagDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tag.
        /// </summary>
        internal static string CustomValidatorDataTagDisplayName {
            get {
                return ResourceManager.GetString("CustomValidatorDataTagDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Custom Validator..
        /// </summary>
        internal static string CustomValidatorDataTypeNameDescription {
            get {
                return ResourceManager.GetString("CustomValidatorDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string CustomValidatorDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("CustomValidatorDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A validator checks if a DateTime value falls within a specified range..
        /// </summary>
        internal static string DateTimeRangeValidatorDataDescription {
            get {
                return ResourceManager.GetString("DateTimeRangeValidatorDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Date Range Validator.
        /// </summary>
        internal static string DateTimeRangeValidatorDataDisplayName {
            get {
                return ResourceManager.GetString("DateTimeRangeValidatorDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The earliest date for which the value is valid..
        /// </summary>
        internal static string DateTimeRangeValidatorDataLowerBoundDescription {
            get {
                return ResourceManager.GetString("DateTimeRangeValidatorDataLowerBoundDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Lower Bound.
        /// </summary>
        internal static string DateTimeRangeValidatorDataLowerBoundDisplayName {
            get {
                return ResourceManager.GetString("DateTimeRangeValidatorDataLowerBoundDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Determines how to evaluate the Lower Bound value. 
        ///Ignore (the default) means that the validator ignores the Lower Bound value. 
        ///Inclusive means that the validator allows values that are equal to the Lower Bound value. 
        ///Exclusive means that the validator does not allow values that are equal to the Lower Bound value..
        /// </summary>
        internal static string DateTimeRangeValidatorDataLowerBoundTypeDescription {
            get {
                return ResourceManager.GetString("DateTimeRangeValidatorDataLowerBoundTypeDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Lower Bound Type.
        /// </summary>
        internal static string DateTimeRangeValidatorDataLowerBoundTypeDisplayName {
            get {
                return ResourceManager.GetString("DateTimeRangeValidatorDataLowerBoundTypeDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The template to use when creating the validation message. 
        ///The template can contain placeholders for values exposed by the individual validation results for each member of the validated type. .
        /// </summary>
        internal static string DateTimeRangeValidatorDataMessageTemplateDescription {
            get {
                return ResourceManager.GetString("DateTimeRangeValidatorDataMessageTemplateDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Message Template.
        /// </summary>
        internal static string DateTimeRangeValidatorDataMessageTemplateDisplayName {
            get {
                return ResourceManager.GetString("DateTimeRangeValidatorDataMessageTemplateDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The key in an external resource file for the localized string to use as the validation message. .
        /// </summary>
        internal static string DateTimeRangeValidatorDataMessageTemplateResourceNameDescription {
            get {
                return ResourceManager.GetString("DateTimeRangeValidatorDataMessageTemplateResourceNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Name.
        /// </summary>
        internal static string DateTimeRangeValidatorDataMessageTemplateResourceNameDisplayName {
            get {
                return ResourceManager.GetString("DateTimeRangeValidatorDataMessageTemplateResourceNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type of the external resource file containing the localized string to use as the validation message. .
        /// </summary>
        internal static string DateTimeRangeValidatorDataMessageTemplateResourceTypeNameDescription {
            get {
                return ResourceManager.GetString("DateTimeRangeValidatorDataMessageTemplateResourceTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Type.
        /// </summary>
        internal static string DateTimeRangeValidatorDataMessageTemplateResourceTypeNameDisplayName {
            get {
                return ResourceManager.GetString("DateTimeRangeValidatorDataMessageTemplateResourceTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Date Time Range Validator..
        /// </summary>
        internal static string DateTimeRangeValidatorDataNameDescription {
            get {
                return ResourceManager.GetString("DateTimeRangeValidatorDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string DateTimeRangeValidatorDataNameDisplayName {
            get {
                return ResourceManager.GetString("DateTimeRangeValidatorDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Reverses the validation behavior. 
        ///When set to True, validation will fail (the validator will return False) if the validation rules are satisfied, instead of the default behavior of failing when they are not satisfied. 
        ///The default is False..
        /// </summary>
        internal static string DateTimeRangeValidatorDataNegatedDescription {
            get {
                return ResourceManager.GetString("DateTimeRangeValidatorDataNegatedDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Negated.
        /// </summary>
        internal static string DateTimeRangeValidatorDataNegatedDisplayName {
            get {
                return ResourceManager.GetString("DateTimeRangeValidatorDataNegatedDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A user-supplied string value that can be used to identify or classify the validator. 
        ///It can be accessed from code, and is typically used to sort or categorize the validation results. .
        /// </summary>
        internal static string DateTimeRangeValidatorDataTagDescription {
            get {
                return ResourceManager.GetString("DateTimeRangeValidatorDataTagDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tag.
        /// </summary>
        internal static string DateTimeRangeValidatorDataTagDisplayName {
            get {
                return ResourceManager.GetString("DateTimeRangeValidatorDataTagDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Date Time Range Validator..
        /// </summary>
        internal static string DateTimeRangeValidatorDataTypeNameDescription {
            get {
                return ResourceManager.GetString("DateTimeRangeValidatorDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string DateTimeRangeValidatorDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("DateTimeRangeValidatorDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The latest date for which the value is valid..
        /// </summary>
        internal static string DateTimeRangeValidatorDataUpperBoundDescription {
            get {
                return ResourceManager.GetString("DateTimeRangeValidatorDataUpperBoundDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Upper Bound.
        /// </summary>
        internal static string DateTimeRangeValidatorDataUpperBoundDisplayName {
            get {
                return ResourceManager.GetString("DateTimeRangeValidatorDataUpperBoundDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Determines how to evaluate the Upper Bound value. 
        ///Ignore (the default) means that the validator ignores the Upper Bound value. 
        ///Inclusive means that the validator allows values that are equal to the Upper Bound value. 
        ///Exclusive means that the validator does not allow values that are equal to the Upper Bound value..
        /// </summary>
        internal static string DateTimeRangeValidatorDataUpperBoundTypeDescription {
            get {
                return ResourceManager.GetString("DateTimeRangeValidatorDataUpperBoundTypeDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Upper Bound Type.
        /// </summary>
        internal static string DateTimeRangeValidatorDataUpperBoundTypeDisplayName {
            get {
                return ResourceManager.GetString("DateTimeRangeValidatorDataUpperBoundTypeDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An individual value within the domain of valid values..
        /// </summary>
        internal static string DomainConfigurationElementDescription {
            get {
                return ResourceManager.GetString("DomainConfigurationElementDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Domain Configuration Element.
        /// </summary>
        internal static string DomainConfigurationElementDisplayName {
            get {
                return ResourceManager.GetString("DomainConfigurationElementDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Domain Configuration Element..
        /// </summary>
        internal static string DomainConfigurationElementNameDescription {
            get {
                return ResourceManager.GetString("DomainConfigurationElementNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string DomainConfigurationElementNameDisplayName {
            get {
                return ResourceManager.GetString("DomainConfigurationElementNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A validator that checks if a value is one of the values in a specified set. 
        ///For example, it can check that a name is &apos;Tom&apos;, &apos;Dick&apos;, &apos;Harry&apos;, or &apos;George&apos;; or that an integer is 2, 3, 5, 7, or 11. 
        ///If the set only contains one value, this validator will effectively check for equality..
        /// </summary>
        internal static string DomainValidatorDataDescription {
            get {
                return ResourceManager.GetString("DomainValidatorDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Domain Validator.
        /// </summary>
        internal static string DomainValidatorDataDisplayName {
            get {
                return ResourceManager.GetString("DomainValidatorDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The set of valid values that validator will compare the specified value against..
        /// </summary>
        internal static string DomainValidatorDataDomainDescription {
            get {
                return ResourceManager.GetString("DomainValidatorDataDomainDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Domain.
        /// </summary>
        internal static string DomainValidatorDataDomainDisplayName {
            get {
                return ResourceManager.GetString("DomainValidatorDataDomainDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The template to use when creating the validation message. 
        ///The template can contain placeholders for values exposed by the individual validation results for each member of the validated type. .
        /// </summary>
        internal static string DomainValidatorDataMessageTemplateDescription {
            get {
                return ResourceManager.GetString("DomainValidatorDataMessageTemplateDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Message Template.
        /// </summary>
        internal static string DomainValidatorDataMessageTemplateDisplayName {
            get {
                return ResourceManager.GetString("DomainValidatorDataMessageTemplateDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The key in an external resource file for the localized string to use as the validation message. .
        /// </summary>
        internal static string DomainValidatorDataMessageTemplateResourceNameDescription {
            get {
                return ResourceManager.GetString("DomainValidatorDataMessageTemplateResourceNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Name.
        /// </summary>
        internal static string DomainValidatorDataMessageTemplateResourceNameDisplayName {
            get {
                return ResourceManager.GetString("DomainValidatorDataMessageTemplateResourceNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type of the external resource file containing the localized string to use as the validation message. .
        /// </summary>
        internal static string DomainValidatorDataMessageTemplateResourceTypeNameDescription {
            get {
                return ResourceManager.GetString("DomainValidatorDataMessageTemplateResourceTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Type.
        /// </summary>
        internal static string DomainValidatorDataMessageTemplateResourceTypeNameDisplayName {
            get {
                return ResourceManager.GetString("DomainValidatorDataMessageTemplateResourceTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Domain Validator..
        /// </summary>
        internal static string DomainValidatorDataNameDescription {
            get {
                return ResourceManager.GetString("DomainValidatorDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string DomainValidatorDataNameDisplayName {
            get {
                return ResourceManager.GetString("DomainValidatorDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Reverses the validation behavior. 
        ///When set to True, validation will fail (the validator will return False) if the validation rules are satisfied, instead of the default behavior of failing when they are not satisfied. 
        ///The default is False..
        /// </summary>
        internal static string DomainValidatorDataNegatedDescription {
            get {
                return ResourceManager.GetString("DomainValidatorDataNegatedDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Negated.
        /// </summary>
        internal static string DomainValidatorDataNegatedDisplayName {
            get {
                return ResourceManager.GetString("DomainValidatorDataNegatedDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A user-supplied string value that can be used to identify or classify the validator. 
        ///It can be accessed from code, and is typically used to sort or categorize the validation results. .
        /// </summary>
        internal static string DomainValidatorDataTagDescription {
            get {
                return ResourceManager.GetString("DomainValidatorDataTagDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tag.
        /// </summary>
        internal static string DomainValidatorDataTagDisplayName {
            get {
                return ResourceManager.GetString("DomainValidatorDataTagDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Domain Validator..
        /// </summary>
        internal static string DomainValidatorDataTypeNameDescription {
            get {
                return ResourceManager.GetString("DomainValidatorDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string DomainValidatorDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("DomainValidatorDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A validator that checks if a string value can be converted to a value in a specified enumeration. 
        ///For example, it can check that &apos;Blue&apos; can be converted to a value in the Color enumeration..
        /// </summary>
        internal static string EnumConversionValidatorDataDescription {
            get {
                return ResourceManager.GetString("EnumConversionValidatorDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Enum Conversion Validator.
        /// </summary>
        internal static string EnumConversionValidatorDataDisplayName {
            get {
                return ResourceManager.GetString("EnumConversionValidatorDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of enumeration to check against..
        /// </summary>
        internal static string EnumConversionValidatorDataEnumTypeNameDescription {
            get {
                return ResourceManager.GetString("EnumConversionValidatorDataEnumTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Enumeration Type.
        /// </summary>
        internal static string EnumConversionValidatorDataEnumTypeNameDisplayName {
            get {
                return ResourceManager.GetString("EnumConversionValidatorDataEnumTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The template to use when creating the validation message. 
        ///The template can contain placeholders for values exposed by the individual validation results for each member of the validated type. .
        /// </summary>
        internal static string EnumConversionValidatorDataMessageTemplateDescription {
            get {
                return ResourceManager.GetString("EnumConversionValidatorDataMessageTemplateDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Message Template.
        /// </summary>
        internal static string EnumConversionValidatorDataMessageTemplateDisplayName {
            get {
                return ResourceManager.GetString("EnumConversionValidatorDataMessageTemplateDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The key in an external resource file for the localized string to use as the validation message. .
        /// </summary>
        internal static string EnumConversionValidatorDataMessageTemplateResourceNameDescription {
            get {
                return ResourceManager.GetString("EnumConversionValidatorDataMessageTemplateResourceNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Name.
        /// </summary>
        internal static string EnumConversionValidatorDataMessageTemplateResourceNameDisplayName {
            get {
                return ResourceManager.GetString("EnumConversionValidatorDataMessageTemplateResourceNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type of the external resource file containing the localized string to use as the validation message. .
        /// </summary>
        internal static string EnumConversionValidatorDataMessageTemplateResourceTypeNameDescription {
            get {
                return ResourceManager.GetString("EnumConversionValidatorDataMessageTemplateResourceTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Type.
        /// </summary>
        internal static string EnumConversionValidatorDataMessageTemplateResourceTypeNameDisplayName {
            get {
                return ResourceManager.GetString("EnumConversionValidatorDataMessageTemplateResourceTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Enum Conversion Validator..
        /// </summary>
        internal static string EnumConversionValidatorDataNameDescription {
            get {
                return ResourceManager.GetString("EnumConversionValidatorDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string EnumConversionValidatorDataNameDisplayName {
            get {
                return ResourceManager.GetString("EnumConversionValidatorDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Reverses the validation behavior. 
        ///When set to True, validation will fail (the validator will return False) if the validation rules are satisfied, instead of the default behavior of failing when they are not satisfied. 
        ///The default is False..
        /// </summary>
        internal static string EnumConversionValidatorDataNegatedDescription {
            get {
                return ResourceManager.GetString("EnumConversionValidatorDataNegatedDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Negated.
        /// </summary>
        internal static string EnumConversionValidatorDataNegatedDisplayName {
            get {
                return ResourceManager.GetString("EnumConversionValidatorDataNegatedDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A user-supplied string value that can be used to identify or classify the validator. 
        ///It can be accessed from code, and is typically used to sort or categorize the validation results. .
        /// </summary>
        internal static string EnumConversionValidatorDataTagDescription {
            get {
                return ResourceManager.GetString("EnumConversionValidatorDataTagDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tag.
        /// </summary>
        internal static string EnumConversionValidatorDataTagDisplayName {
            get {
                return ResourceManager.GetString("EnumConversionValidatorDataTagDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Enum Conversion Validator..
        /// </summary>
        internal static string EnumConversionValidatorDataTypeNameDescription {
            get {
                return ResourceManager.GetString("EnumConversionValidatorDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string EnumConversionValidatorDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("EnumConversionValidatorDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A validator that checks that a value is not null (C#) or Nothing (Visual Basic)..
        /// </summary>
        internal static string NotNullValidatorDataDescription {
            get {
                return ResourceManager.GetString("NotNullValidatorDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Not Null Validator.
        /// </summary>
        internal static string NotNullValidatorDataDisplayName {
            get {
                return ResourceManager.GetString("NotNullValidatorDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The template to use when creating the validation message. 
        ///The template can contain placeholders for values exposed by the individual validation results for each member of the validated type..
        /// </summary>
        internal static string NotNullValidatorDataMessageTemplateDescription {
            get {
                return ResourceManager.GetString("NotNullValidatorDataMessageTemplateDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Message Template.
        /// </summary>
        internal static string NotNullValidatorDataMessageTemplateDisplayName {
            get {
                return ResourceManager.GetString("NotNullValidatorDataMessageTemplateDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The key in an external resource file for the localized string to use as the validation message. .
        /// </summary>
        internal static string NotNullValidatorDataMessageTemplateResourceNameDescription {
            get {
                return ResourceManager.GetString("NotNullValidatorDataMessageTemplateResourceNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Name.
        /// </summary>
        internal static string NotNullValidatorDataMessageTemplateResourceNameDisplayName {
            get {
                return ResourceManager.GetString("NotNullValidatorDataMessageTemplateResourceNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type of the external resource file containing the localized string to use as the validation message. .
        /// </summary>
        internal static string NotNullValidatorDataMessageTemplateResourceTypeNameDescription {
            get {
                return ResourceManager.GetString("NotNullValidatorDataMessageTemplateResourceTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Type.
        /// </summary>
        internal static string NotNullValidatorDataMessageTemplateResourceTypeNameDisplayName {
            get {
                return ResourceManager.GetString("NotNullValidatorDataMessageTemplateResourceTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Not Null Validator..
        /// </summary>
        internal static string NotNullValidatorDataNameDescription {
            get {
                return ResourceManager.GetString("NotNullValidatorDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string NotNullValidatorDataNameDisplayName {
            get {
                return ResourceManager.GetString("NotNullValidatorDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Reverses the validation behavior. 
        ///When set to True, validation will fail (the validator will return False) if the validation rules are satisfied, instead of the default behavior of failing when they are not satisfied. 
        ///The default is False..
        /// </summary>
        internal static string NotNullValidatorDataNegatedDescription {
            get {
                return ResourceManager.GetString("NotNullValidatorDataNegatedDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Negated.
        /// </summary>
        internal static string NotNullValidatorDataNegatedDisplayName {
            get {
                return ResourceManager.GetString("NotNullValidatorDataNegatedDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A user-supplied string value that can be used to identify or classify the validator. 
        ///It can be accessed from code, and is typically used to sort or categorize the validation results. .
        /// </summary>
        internal static string NotNullValidatorDataTagDescription {
            get {
                return ResourceManager.GetString("NotNullValidatorDataTagDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tag.
        /// </summary>
        internal static string NotNullValidatorDataTagDisplayName {
            get {
                return ResourceManager.GetString("NotNullValidatorDataTagDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Not Null Validator..
        /// </summary>
        internal static string NotNullValidatorDataTypeNameDescription {
            get {
                return ResourceManager.GetString("NotNullValidatorDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string NotNullValidatorDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("NotNullValidatorDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A validator that checks if the validated value is a collection of the specified type, and then invokes validation on each element of the collection. 
        ///If the object to validate is null, validation is ignored. If the object to validate is not a collection, validation fails and self validation is not applied. 
        ///If there are elements in the collection that are of a different type than the one specified for the Target Type, validation for these elements fails but this does not affect validation for the other el [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string ObjectCollectionValidatorDataDescription {
            get {
                return ResourceManager.GetString("ObjectCollectionValidatorDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Object Collection Validator.
        /// </summary>
        internal static string ObjectCollectionValidatorDataDisplayName {
            get {
                return ResourceManager.GetString("ObjectCollectionValidatorDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The template to use when creating the validation message. 
        ///The template can contain placeholders for values exposed by the individual validation results for each member of the validated type. .
        /// </summary>
        internal static string ObjectCollectionValidatorDataMessageTemplateDescription {
            get {
                return ResourceManager.GetString("ObjectCollectionValidatorDataMessageTemplateDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Message Template.
        /// </summary>
        internal static string ObjectCollectionValidatorDataMessageTemplateDisplayName {
            get {
                return ResourceManager.GetString("ObjectCollectionValidatorDataMessageTemplateDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The key in an external resource file for the localized string to use as the validation message. .
        /// </summary>
        internal static string ObjectCollectionValidatorDataMessageTemplateResourceNameDescription {
            get {
                return ResourceManager.GetString("ObjectCollectionValidatorDataMessageTemplateResourceNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Name.
        /// </summary>
        internal static string ObjectCollectionValidatorDataMessageTemplateResourceNameDisplayName {
            get {
                return ResourceManager.GetString("ObjectCollectionValidatorDataMessageTemplateResourceNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type of the external resource file containing the localized string to use as the validation message. .
        /// </summary>
        internal static string ObjectCollectionValidatorDataMessageTemplateResourceTypeNameDescription {
            get {
                return ResourceManager.GetString("ObjectCollectionValidatorDataMessageTemplateResourceTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Type.
        /// </summary>
        internal static string ObjectCollectionValidatorDataMessageTemplateResourceTypeNameDisplayName {
            get {
                return ResourceManager.GetString("ObjectCollectionValidatorDataMessageTemplateResourceTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Object Collection Validator..
        /// </summary>
        internal static string ObjectCollectionValidatorDataNameDescription {
            get {
                return ResourceManager.GetString("ObjectCollectionValidatorDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string ObjectCollectionValidatorDataNameDisplayName {
            get {
                return ResourceManager.GetString("ObjectCollectionValidatorDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A user-supplied string value that can be used to identify or classify the validator. 
        ///It can be accessed from code, and is typically used to sort or categorize the validation results. .
        /// </summary>
        internal static string ObjectCollectionValidatorDataTagDescription {
            get {
                return ResourceManager.GetString("ObjectCollectionValidatorDataTagDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tag.
        /// </summary>
        internal static string ObjectCollectionValidatorDataTagDisplayName {
            get {
                return ResourceManager.GetString("ObjectCollectionValidatorDataTagDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to  The name of the rule set that will be applied to each element in the collection..
        /// </summary>
        internal static string ObjectCollectionValidatorDataTargetRulesetDescription {
            get {
                return ResourceManager.GetString("ObjectCollectionValidatorDataTargetRulesetDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Target Ruleset.
        /// </summary>
        internal static string ObjectCollectionValidatorDataTargetRulesetDisplayName {
            get {
                return ResourceManager.GetString("ObjectCollectionValidatorDataTargetRulesetDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the collection to validate..
        /// </summary>
        internal static string ObjectCollectionValidatorDataTargetTypeNameDescription {
            get {
                return ResourceManager.GetString("ObjectCollectionValidatorDataTargetTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Target Type.
        /// </summary>
        internal static string ObjectCollectionValidatorDataTargetTypeNameDisplayName {
            get {
                return ResourceManager.GetString("ObjectCollectionValidatorDataTargetTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Object Collection Validator..
        /// </summary>
        internal static string ObjectCollectionValidatorDataTypeNameDescription {
            get {
                return ResourceManager.GetString("ObjectCollectionValidatorDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string ObjectCollectionValidatorDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("ObjectCollectionValidatorDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A validator that causes validation to occur on a referenced object. 
        ///All validators defined for that type will be invoked as if the Validate method had been called on the object. 
        ///If the object to validate is null, validation is ignored. 
        ///If the reference is to an instance of a type that is not compatible with the configured target type, validation fails. 
        ///This validator is useful for validating tree-structured data..
        /// </summary>
        internal static string ObjectValidatorDataDescription {
            get {
                return ResourceManager.GetString("ObjectValidatorDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Object Validator.
        /// </summary>
        internal static string ObjectValidatorDataDisplayName {
            get {
                return ResourceManager.GetString("ObjectValidatorDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The template to use when creating the validation message. 
        ///The template can contain placeholders for values exposed by the individual validation results for each member of the validated type. .
        /// </summary>
        internal static string ObjectValidatorDataMessageTemplateDescription {
            get {
                return ResourceManager.GetString("ObjectValidatorDataMessageTemplateDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Message Template.
        /// </summary>
        internal static string ObjectValidatorDataMessageTemplateDisplayName {
            get {
                return ResourceManager.GetString("ObjectValidatorDataMessageTemplateDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The key in an external resource file for the localized string to use as the validation message. .
        /// </summary>
        internal static string ObjectValidatorDataMessageTemplateResourceNameDescription {
            get {
                return ResourceManager.GetString("ObjectValidatorDataMessageTemplateResourceNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Name.
        /// </summary>
        internal static string ObjectValidatorDataMessageTemplateResourceNameDisplayName {
            get {
                return ResourceManager.GetString("ObjectValidatorDataMessageTemplateResourceNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type of the external resource file containing the localized string to use as the validation message. .
        /// </summary>
        internal static string ObjectValidatorDataMessageTemplateResourceTypeNameDescription {
            get {
                return ResourceManager.GetString("ObjectValidatorDataMessageTemplateResourceTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Type.
        /// </summary>
        internal static string ObjectValidatorDataMessageTemplateResourceTypeNameDisplayName {
            get {
                return ResourceManager.GetString("ObjectValidatorDataMessageTemplateResourceTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Object Validator..
        /// </summary>
        internal static string ObjectValidatorDataNameDescription {
            get {
                return ResourceManager.GetString("ObjectValidatorDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string ObjectValidatorDataNameDisplayName {
            get {
                return ResourceManager.GetString("ObjectValidatorDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A user-supplied string value that can be used to identify or classify the validator. 
        ///It can be accessed from code, and is typically used to sort or categorize the validation results. .
        /// </summary>
        internal static string ObjectValidatorDataTagDescription {
            get {
                return ResourceManager.GetString("ObjectValidatorDataTagDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tag.
        /// </summary>
        internal static string ObjectValidatorDataTagDisplayName {
            get {
                return ResourceManager.GetString("ObjectValidatorDataTagDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to  The name of the rule set to apply to the target object..
        /// </summary>
        internal static string ObjectValidatorDataTargetRulesetDescription {
            get {
                return ResourceManager.GetString("ObjectValidatorDataTargetRulesetDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Target Ruleset.
        /// </summary>
        internal static string ObjectValidatorDataTargetRulesetDisplayName {
            get {
                return ResourceManager.GetString("ObjectValidatorDataTargetRulesetDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Object Validator..
        /// </summary>
        internal static string ObjectValidatorDataTypeNameDescription {
            get {
                return ResourceManager.GetString("ObjectValidatorDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string ObjectValidatorDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("ObjectValidatorDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A flag indicating whether the value should be validated using the rules for its runtime type, not its static type..
        /// </summary>
        internal static string ObjectValidatorDataValidateActualTypeDescription {
            get {
                return ResourceManager.GetString("ObjectValidatorDataValidateActualTypeDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Validate actual type.
        /// </summary>
        internal static string ObjectValidatorDataValidateActualTypeDisplayName {
            get {
                return ResourceManager.GetString("ObjectValidatorDataValidateActualTypeDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Provides the capability to create complex validation rules using a hierarchy of nested validators. 
        ///This validator returns True when any of the validators it contains returns True for the validated type..
        /// </summary>
        internal static string OrCompositeValidatorDataDescription {
            get {
                return ResourceManager.GetString("OrCompositeValidatorDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Or Composite Validator.
        /// </summary>
        internal static string OrCompositeValidatorDataDisplayName {
            get {
                return ResourceManager.GetString("OrCompositeValidatorDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The template to use when creating the validation message. 
        ///The template can contain placeholders for values exposed by the individual validation results for each member of the validated type. .
        /// </summary>
        internal static string OrCompositeValidatorDataMessageTemplateDescription {
            get {
                return ResourceManager.GetString("OrCompositeValidatorDataMessageTemplateDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Message Template.
        /// </summary>
        internal static string OrCompositeValidatorDataMessageTemplateDisplayName {
            get {
                return ResourceManager.GetString("OrCompositeValidatorDataMessageTemplateDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The key in an external resource file for the localized string to use as the validation message. .
        /// </summary>
        internal static string OrCompositeValidatorDataMessageTemplateResourceNameDescription {
            get {
                return ResourceManager.GetString("OrCompositeValidatorDataMessageTemplateResourceNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Name.
        /// </summary>
        internal static string OrCompositeValidatorDataMessageTemplateResourceNameDisplayName {
            get {
                return ResourceManager.GetString("OrCompositeValidatorDataMessageTemplateResourceNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type of the external resource file containing the localized string to use as the validation message. .
        /// </summary>
        internal static string OrCompositeValidatorDataMessageTemplateResourceTypeNameDescription {
            get {
                return ResourceManager.GetString("OrCompositeValidatorDataMessageTemplateResourceTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Type.
        /// </summary>
        internal static string OrCompositeValidatorDataMessageTemplateResourceTypeNameDisplayName {
            get {
                return ResourceManager.GetString("OrCompositeValidatorDataMessageTemplateResourceTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Or Composite Validator..
        /// </summary>
        internal static string OrCompositeValidatorDataNameDescription {
            get {
                return ResourceManager.GetString("OrCompositeValidatorDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string OrCompositeValidatorDataNameDisplayName {
            get {
                return ResourceManager.GetString("OrCompositeValidatorDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A user-supplied string value that can be used to identify or classify the validator. 
        ///It can be accessed from code, and is typically used to sort or categorize the validation results. .
        /// </summary>
        internal static string OrCompositeValidatorDataTagDescription {
            get {
                return ResourceManager.GetString("OrCompositeValidatorDataTagDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tag.
        /// </summary>
        internal static string OrCompositeValidatorDataTagDisplayName {
            get {
                return ResourceManager.GetString("OrCompositeValidatorDataTagDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Or Composite Validator..
        /// </summary>
        internal static string OrCompositeValidatorDataTypeNameDescription {
            get {
                return ResourceManager.GetString("OrCompositeValidatorDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string OrCompositeValidatorDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("OrCompositeValidatorDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collection of validators nested within this validator, any one of which can return True for this validator to return True..
        /// </summary>
        internal static string OrCompositeValidatorDataValidatorsDescription {
            get {
                return ResourceManager.GetString("OrCompositeValidatorDataValidatorsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Validators.
        /// </summary>
        internal static string OrCompositeValidatorDataValidatorsDisplayName {
            get {
                return ResourceManager.GetString("OrCompositeValidatorDataValidatorsDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Determines how the two values are compared. 
        ///The comparisons available are Equal, NotEqual, GreaterThan, GreaterThanEqual, LessThan, and LessThanEqual..
        /// </summary>
        internal static string PropertyComparisonValidatorDataComparisonOperatorDescription {
            get {
                return ResourceManager.GetString("PropertyComparisonValidatorDataComparisonOperatorDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Comparison Operator.
        /// </summary>
        internal static string PropertyComparisonValidatorDataComparisonOperatorDisplayName {
            get {
                return ResourceManager.GetString("PropertyComparisonValidatorDataComparisonOperatorDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A validator that compares the value to be validated with the value of a specified property of the type being validated..
        /// </summary>
        internal static string PropertyComparisonValidatorDataDescription {
            get {
                return ResourceManager.GetString("PropertyComparisonValidatorDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Property Comparison Validator.
        /// </summary>
        internal static string PropertyComparisonValidatorDataDisplayName {
            get {
                return ResourceManager.GetString("PropertyComparisonValidatorDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The template to use when creating the validation message. 
        ///The template can contain placeholders for values exposed by the individual validation results for each member of the validated type. .
        /// </summary>
        internal static string PropertyComparisonValidatorDataMessageTemplateDescription {
            get {
                return ResourceManager.GetString("PropertyComparisonValidatorDataMessageTemplateDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Message Template.
        /// </summary>
        internal static string PropertyComparisonValidatorDataMessageTemplateDisplayName {
            get {
                return ResourceManager.GetString("PropertyComparisonValidatorDataMessageTemplateDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The key in an external resource file for the localized string to use as the validation message. .
        /// </summary>
        internal static string PropertyComparisonValidatorDataMessageTemplateResourceNameDescription {
            get {
                return ResourceManager.GetString("PropertyComparisonValidatorDataMessageTemplateResourceNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Name.
        /// </summary>
        internal static string PropertyComparisonValidatorDataMessageTemplateResourceNameDisplayName {
            get {
                return ResourceManager.GetString("PropertyComparisonValidatorDataMessageTemplateResourceNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type of the external resource file containing the localized string to use as the validation message. .
        /// </summary>
        internal static string PropertyComparisonValidatorDataMessageTemplateResourceTypeNameDescription {
            get {
                return ResourceManager.GetString("PropertyComparisonValidatorDataMessageTemplateResourceTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Type.
        /// </summary>
        internal static string PropertyComparisonValidatorDataMessageTemplateResourceTypeNameDisplayName {
            get {
                return ResourceManager.GetString("PropertyComparisonValidatorDataMessageTemplateResourceTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Property Comparison Validator..
        /// </summary>
        internal static string PropertyComparisonValidatorDataNameDescription {
            get {
                return ResourceManager.GetString("PropertyComparisonValidatorDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string PropertyComparisonValidatorDataNameDisplayName {
            get {
                return ResourceManager.GetString("PropertyComparisonValidatorDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Reverses the validation behavior. When set to True, validation will fail (the validator will return False) 
        ///if the validation rules are satisfied, instead of the default behavior of failing when they are not satisfied. The default is False..
        /// </summary>
        internal static string PropertyComparisonValidatorDataNegatedDescription {
            get {
                return ResourceManager.GetString("PropertyComparisonValidatorDataNegatedDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Negated.
        /// </summary>
        internal static string PropertyComparisonValidatorDataNegatedDisplayName {
            get {
                return ResourceManager.GetString("PropertyComparisonValidatorDataNegatedDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the property of the type being validated that will be compared with the value to validate..
        /// </summary>
        internal static string PropertyComparisonValidatorDataPropertyToCompareDescription {
            get {
                return ResourceManager.GetString("PropertyComparisonValidatorDataPropertyToCompareDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Property To Compare.
        /// </summary>
        internal static string PropertyComparisonValidatorDataPropertyToCompareDisplayName {
            get {
                return ResourceManager.GetString("PropertyComparisonValidatorDataPropertyToCompareDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A user-supplied string value that can be used to identify or classify the validator. 
        ///It can be accessed from code, and is typically used to sort or categorize the validation results. .
        /// </summary>
        internal static string PropertyComparisonValidatorDataTagDescription {
            get {
                return ResourceManager.GetString("PropertyComparisonValidatorDataTagDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tag.
        /// </summary>
        internal static string PropertyComparisonValidatorDataTagDisplayName {
            get {
                return ResourceManager.GetString("PropertyComparisonValidatorDataTagDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Property Comparison Validator..
        /// </summary>
        internal static string PropertyComparisonValidatorDataTypeNameDescription {
            get {
                return ResourceManager.GetString("PropertyComparisonValidatorDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string PropertyComparisonValidatorDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("PropertyComparisonValidatorDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The culture which is used to deserialized the Lower Bound and Upper Bound values..
        /// </summary>
        internal static string RangeValidatorDataCultureDescription {
            get {
                return ResourceManager.GetString("RangeValidatorDataCultureDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Culture.
        /// </summary>
        internal static string RangeValidatorDataCultureDisplayName {
            get {
                return ResourceManager.GetString("RangeValidatorDataCultureDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A validator that checks if a value falls within a specified range. 
        ///The range may be closed (it has both a lower and an upper bound specified), or open (it only has one bound specified)..
        /// </summary>
        internal static string RangeValidatorDataDescription {
            get {
                return ResourceManager.GetString("RangeValidatorDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A validator that checks if a value falls within a specified range. 
        ///The range may be closed (it has both a lower and an upper bound specified), or open (it only has one bound specified)..
        /// </summary>
        internal static string RangeValidatorDataDescription1 {
            get {
                return ResourceManager.GetString("RangeValidatorDataDescription1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Range Validator.
        /// </summary>
        internal static string RangeValidatorDataDisplayName {
            get {
                return ResourceManager.GetString("RangeValidatorDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Generic Range Validator.
        /// </summary>
        internal static string RangeValidatorDataDisplayName1 {
            get {
                return ResourceManager.GetString("RangeValidatorDataDisplayName1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The lower bound for the value being validated..
        /// </summary>
        internal static string RangeValidatorDataLowerBoundDescription {
            get {
                return ResourceManager.GetString("RangeValidatorDataLowerBoundDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The lower bound for the value being validated..
        /// </summary>
        internal static string RangeValidatorDataLowerBoundDescription1 {
            get {
                return ResourceManager.GetString("RangeValidatorDataLowerBoundDescription1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Lower Bound.
        /// </summary>
        internal static string RangeValidatorDataLowerBoundDisplayName {
            get {
                return ResourceManager.GetString("RangeValidatorDataLowerBoundDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Lower Bound.
        /// </summary>
        internal static string RangeValidatorDataLowerBoundDisplayName1 {
            get {
                return ResourceManager.GetString("RangeValidatorDataLowerBoundDisplayName1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Determines how to evaluate the Lower Bound value. 
        ///Ignore (the default) means that the validator ignores the Lower Bound value. Inclusive means that the validator allows values that are equal to the Lower Bound value. 
        ///Exclusive means that the validator does not allow values that are equal to the Lower Bound value..
        /// </summary>
        internal static string RangeValidatorDataLowerBoundTypeDescription {
            get {
                return ResourceManager.GetString("RangeValidatorDataLowerBoundTypeDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Determines how to evaluate the Lower Bound value. 
        ///Ignore (the default) means that the validator ignores the Lower Bound value. Inclusive means that the validator allows values that are equal to the Lower Bound value. 
        ///Exclusive means that the validator does not allow values that are equal to the Lower Bound value..
        /// </summary>
        internal static string RangeValidatorDataLowerBoundTypeDescription1 {
            get {
                return ResourceManager.GetString("RangeValidatorDataLowerBoundTypeDescription1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Lower Bound Type.
        /// </summary>
        internal static string RangeValidatorDataLowerBoundTypeDisplayName {
            get {
                return ResourceManager.GetString("RangeValidatorDataLowerBoundTypeDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Lower Bound Type.
        /// </summary>
        internal static string RangeValidatorDataLowerBoundTypeDisplayName1 {
            get {
                return ResourceManager.GetString("RangeValidatorDataLowerBoundTypeDisplayName1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The template to use when creating the validation message. 
        ///The template can contain placeholders for values exposed by the individual validation results for each member of the validated type. .
        /// </summary>
        internal static string RangeValidatorDataMessageTemplateDescription {
            get {
                return ResourceManager.GetString("RangeValidatorDataMessageTemplateDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The template to use when creating the validation message. 
        ///The template can contain placeholders for values exposed by the individual validation results for each member of the validated type. .
        /// </summary>
        internal static string RangeValidatorDataMessageTemplateDescription1 {
            get {
                return ResourceManager.GetString("RangeValidatorDataMessageTemplateDescription1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Message Template.
        /// </summary>
        internal static string RangeValidatorDataMessageTemplateDisplayName {
            get {
                return ResourceManager.GetString("RangeValidatorDataMessageTemplateDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Message Template.
        /// </summary>
        internal static string RangeValidatorDataMessageTemplateDisplayName1 {
            get {
                return ResourceManager.GetString("RangeValidatorDataMessageTemplateDisplayName1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The key in an external resource file for the localized string to use as the validation message. .
        /// </summary>
        internal static string RangeValidatorDataMessageTemplateResourceNameDescription {
            get {
                return ResourceManager.GetString("RangeValidatorDataMessageTemplateResourceNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The key in an external resource file for the localized string to use as the validation message. .
        /// </summary>
        internal static string RangeValidatorDataMessageTemplateResourceNameDescription1 {
            get {
                return ResourceManager.GetString("RangeValidatorDataMessageTemplateResourceNameDescription1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Name.
        /// </summary>
        internal static string RangeValidatorDataMessageTemplateResourceNameDisplayName {
            get {
                return ResourceManager.GetString("RangeValidatorDataMessageTemplateResourceNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Name.
        /// </summary>
        internal static string RangeValidatorDataMessageTemplateResourceNameDisplayName1 {
            get {
                return ResourceManager.GetString("RangeValidatorDataMessageTemplateResourceNameDisplayName1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type of the external resource file containing the localized string to use as the validation message. .
        /// </summary>
        internal static string RangeValidatorDataMessageTemplateResourceTypeNameDescription {
            get {
                return ResourceManager.GetString("RangeValidatorDataMessageTemplateResourceTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type of the external resource file containing the localized string to use as the validation message. .
        /// </summary>
        internal static string RangeValidatorDataMessageTemplateResourceTypeNameDescription1 {
            get {
                return ResourceManager.GetString("RangeValidatorDataMessageTemplateResourceTypeNameDescription1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Type.
        /// </summary>
        internal static string RangeValidatorDataMessageTemplateResourceTypeNameDisplayName {
            get {
                return ResourceManager.GetString("RangeValidatorDataMessageTemplateResourceTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Type.
        /// </summary>
        internal static string RangeValidatorDataMessageTemplateResourceTypeNameDisplayName1 {
            get {
                return ResourceManager.GetString("RangeValidatorDataMessageTemplateResourceTypeNameDisplayName1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Range Validator..
        /// </summary>
        internal static string RangeValidatorDataNameDescription {
            get {
                return ResourceManager.GetString("RangeValidatorDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Range Validator..
        /// </summary>
        internal static string RangeValidatorDataNameDescription1 {
            get {
                return ResourceManager.GetString("RangeValidatorDataNameDescription1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string RangeValidatorDataNameDisplayName {
            get {
                return ResourceManager.GetString("RangeValidatorDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string RangeValidatorDataNameDisplayName1 {
            get {
                return ResourceManager.GetString("RangeValidatorDataNameDisplayName1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Reverses the validation behavior. When set to True, validation will fail (the validator will return False) 
        ///if the validation rules are satisfied, instead of the default behavior of failing when they are not satisfied. 
        ///The default is False..
        /// </summary>
        internal static string RangeValidatorDataNegatedDescription {
            get {
                return ResourceManager.GetString("RangeValidatorDataNegatedDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Reverses the validation behavior. When set to True, validation will fail (the validator will return False) 
        ///if the validation rules are satisfied, instead of the default behavior of failing when they are not satisfied. 
        ///The default is False..
        /// </summary>
        internal static string RangeValidatorDataNegatedDescription1 {
            get {
                return ResourceManager.GetString("RangeValidatorDataNegatedDescription1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Negated.
        /// </summary>
        internal static string RangeValidatorDataNegatedDisplayName {
            get {
                return ResourceManager.GetString("RangeValidatorDataNegatedDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Negated.
        /// </summary>
        internal static string RangeValidatorDataNegatedDisplayName1 {
            get {
                return ResourceManager.GetString("RangeValidatorDataNegatedDisplayName1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A user-supplied string value that can be used to identify or classify the validator. 
        ///It can be accessed from code, and is typically used to sort or categorize the validation results. .
        /// </summary>
        internal static string RangeValidatorDataTagDescription {
            get {
                return ResourceManager.GetString("RangeValidatorDataTagDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A user-supplied string value that can be used to identify or classify the validator. 
        ///It can be accessed from code, and is typically used to sort or categorize the validation results. .
        /// </summary>
        internal static string RangeValidatorDataTagDescription1 {
            get {
                return ResourceManager.GetString("RangeValidatorDataTagDescription1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tag.
        /// </summary>
        internal static string RangeValidatorDataTagDisplayName {
            get {
                return ResourceManager.GetString("RangeValidatorDataTagDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tag.
        /// </summary>
        internal static string RangeValidatorDataTagDisplayName1 {
            get {
                return ResourceManager.GetString("RangeValidatorDataTagDisplayName1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Range Validator..
        /// </summary>
        internal static string RangeValidatorDataTypeNameDescription {
            get {
                return ResourceManager.GetString("RangeValidatorDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Range Validator..
        /// </summary>
        internal static string RangeValidatorDataTypeNameDescription1 {
            get {
                return ResourceManager.GetString("RangeValidatorDataTypeNameDescription1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string RangeValidatorDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("RangeValidatorDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string RangeValidatorDataTypeNameDisplayName1 {
            get {
                return ResourceManager.GetString("RangeValidatorDataTypeNameDisplayName1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The upper bound for the value being validated..
        /// </summary>
        internal static string RangeValidatorDataUpperBoundDescription {
            get {
                return ResourceManager.GetString("RangeValidatorDataUpperBoundDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The upper bound for the value being validated..
        /// </summary>
        internal static string RangeValidatorDataUpperBoundDescription1 {
            get {
                return ResourceManager.GetString("RangeValidatorDataUpperBoundDescription1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Upper Bound.
        /// </summary>
        internal static string RangeValidatorDataUpperBoundDisplayName {
            get {
                return ResourceManager.GetString("RangeValidatorDataUpperBoundDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Upper Bound.
        /// </summary>
        internal static string RangeValidatorDataUpperBoundDisplayName1 {
            get {
                return ResourceManager.GetString("RangeValidatorDataUpperBoundDisplayName1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Determines how to evaluate the Upper Bound value. 
        ///Ignore (the default) means that the validator ignores the Upper Bound value.
        ///Inclusive means that the validator allows values that are equal to the Upper Bound value. 
        ///Exclusive means that the validator does not allow values that are equal to the Upper Bound value..
        /// </summary>
        internal static string RangeValidatorDataUpperBoundTypeDescription {
            get {
                return ResourceManager.GetString("RangeValidatorDataUpperBoundTypeDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Determines how to evaluate the Upper Bound value. 
        ///Ignore (the default) means that the validator ignores the Upper Bound value. 
        ///Inclusive means that the validator allows values that are equal to the Upper Bound value. 
        ///Exclusive means that the validator does not allow values that are equal to the Upper Bound value..
        /// </summary>
        internal static string RangeValidatorDataUpperBoundTypeDescription1 {
            get {
                return ResourceManager.GetString("RangeValidatorDataUpperBoundTypeDescription1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Upper Bound Type.
        /// </summary>
        internal static string RangeValidatorDataUpperBoundTypeDisplayName {
            get {
                return ResourceManager.GetString("RangeValidatorDataUpperBoundTypeDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Upper Bound Type.
        /// </summary>
        internal static string RangeValidatorDataUpperBoundTypeDisplayName1 {
            get {
                return ResourceManager.GetString("RangeValidatorDataUpperBoundTypeDisplayName1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A validator that checks if the value matches the pattern specified by a regular expression..
        /// </summary>
        internal static string RegexValidatorDataDescription {
            get {
                return ResourceManager.GetString("RegexValidatorDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Regular Expression Validator.
        /// </summary>
        internal static string RegexValidatorDataDisplayName {
            get {
                return ResourceManager.GetString("RegexValidatorDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The template to use when creating the validation message. 
        ///The template can contain placeholders for values exposed by the individual validation results for each member of the validated type. .
        /// </summary>
        internal static string RegexValidatorDataMessageTemplateDescription {
            get {
                return ResourceManager.GetString("RegexValidatorDataMessageTemplateDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Message Template.
        /// </summary>
        internal static string RegexValidatorDataMessageTemplateDisplayName {
            get {
                return ResourceManager.GetString("RegexValidatorDataMessageTemplateDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The key in an external resource file for the localized string to use as the validation message. .
        /// </summary>
        internal static string RegexValidatorDataMessageTemplateResourceNameDescription {
            get {
                return ResourceManager.GetString("RegexValidatorDataMessageTemplateResourceNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Name.
        /// </summary>
        internal static string RegexValidatorDataMessageTemplateResourceNameDisplayName {
            get {
                return ResourceManager.GetString("RegexValidatorDataMessageTemplateResourceNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type of the external resource file containing the localized string to use as the validation message. .
        /// </summary>
        internal static string RegexValidatorDataMessageTemplateResourceTypeNameDescription {
            get {
                return ResourceManager.GetString("RegexValidatorDataMessageTemplateResourceTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Type.
        /// </summary>
        internal static string RegexValidatorDataMessageTemplateResourceTypeNameDisplayName {
            get {
                return ResourceManager.GetString("RegexValidatorDataMessageTemplateResourceTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Regular Expression Validator..
        /// </summary>
        internal static string RegexValidatorDataNameDescription {
            get {
                return ResourceManager.GetString("RegexValidatorDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string RegexValidatorDataNameDisplayName {
            get {
                return ResourceManager.GetString("RegexValidatorDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Reverses the validation behavior. 
        ///When set to True, validation will fail (the validator will return False) if the validation rules are satisfied, instead of the default behavior of failing when they are not satisfied. The default is False..
        /// </summary>
        internal static string RegexValidatorDataNegatedDescription {
            get {
                return ResourceManager.GetString("RegexValidatorDataNegatedDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Negated.
        /// </summary>
        internal static string RegexValidatorDataNegatedDisplayName {
            get {
                return ResourceManager.GetString("RegexValidatorDataNegatedDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The RegEx options to apply when validating a pattern. 
        ///Possible values are None (the default), IgnoreCase, Multiline, ExplicitCapture, Compiled, Singleline, IgnorePatternWhiteSpace, and RightToLeft..
        /// </summary>
        internal static string RegexValidatorDataOptionsDescription {
            get {
                return ResourceManager.GetString("RegexValidatorDataOptionsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Options.
        /// </summary>
        internal static string RegexValidatorDataOptionsDisplayName {
            get {
                return ResourceManager.GetString("RegexValidatorDataOptionsDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The regular expression or pattern to use to validate the value..
        /// </summary>
        internal static string RegexValidatorDataPatternDescription {
            get {
                return ResourceManager.GetString("RegexValidatorDataPatternDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Regular Expression.
        /// </summary>
        internal static string RegexValidatorDataPatternDisplayName {
            get {
                return ResourceManager.GetString("RegexValidatorDataPatternDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The key in an external resource file for the localized string to use as the regular expression. .
        /// </summary>
        internal static string RegexValidatorDataPatternResourceNameDescription {
            get {
                return ResourceManager.GetString("RegexValidatorDataPatternResourceNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to RegEx Resource Name.
        /// </summary>
        internal static string RegexValidatorDataPatternResourceNameDisplayName {
            get {
                return ResourceManager.GetString("RegexValidatorDataPatternResourceNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type of the external resource file containing the localized string to use as the regular expression. .
        /// </summary>
        internal static string RegexValidatorDataPatternResourceTypeNameDescription {
            get {
                return ResourceManager.GetString("RegexValidatorDataPatternResourceTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to RegEx Resource Type.
        /// </summary>
        internal static string RegexValidatorDataPatternResourceTypeNameDisplayName {
            get {
                return ResourceManager.GetString("RegexValidatorDataPatternResourceTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A user-supplied string value that can be used to identify or classify the validator. 
        ///It can be accessed from code, and is typically used to sort or categorize the validation results. .
        /// </summary>
        internal static string RegexValidatorDataTagDescription {
            get {
                return ResourceManager.GetString("RegexValidatorDataTagDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tag.
        /// </summary>
        internal static string RegexValidatorDataTagDisplayName {
            get {
                return ResourceManager.GetString("RegexValidatorDataTagDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Regular Expression Validator..
        /// </summary>
        internal static string RegexValidatorDataTypeNameDescription {
            get {
                return ResourceManager.GetString("RegexValidatorDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string RegexValidatorDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("RegexValidatorDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A validator that checks if a DateTime value falls within a specified range using relative times and dates. .
        /// </summary>
        internal static string RelativeDateTimeValidatorDataDescription {
            get {
                return ResourceManager.GetString("RelativeDateTimeValidatorDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Relative Date Time Validator.
        /// </summary>
        internal static string RelativeDateTimeValidatorDataDisplayName {
            get {
                return ResourceManager.GetString("RelativeDateTimeValidatorDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The number of a specific unit of time (such as days) before the date being validated. 
        ///The result is the minimum valid date and time..
        /// </summary>
        internal static string RelativeDateTimeValidatorDataLowerBoundDescription {
            get {
                return ResourceManager.GetString("RelativeDateTimeValidatorDataLowerBoundDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Lower Bound.
        /// </summary>
        internal static string RelativeDateTimeValidatorDataLowerBoundDisplayName {
            get {
                return ResourceManager.GetString("RelativeDateTimeValidatorDataLowerBoundDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Determines how to evaluate the Lower Bound value. 
        ///Ignore (the default) means that the validator ignores the Lower Bound value. 
        ///Inclusive means that the validator allows values that are equal to the Lower Bound value. 
        ///Exclusive means that the validator does not allow values that are equal to the Lower Bound value..
        /// </summary>
        internal static string RelativeDateTimeValidatorDataLowerBoundTypeDescription {
            get {
                return ResourceManager.GetString("RelativeDateTimeValidatorDataLowerBoundTypeDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Lower Bound Type.
        /// </summary>
        internal static string RelativeDateTimeValidatorDataLowerBoundTypeDisplayName {
            get {
                return ResourceManager.GetString("RelativeDateTimeValidatorDataLowerBoundTypeDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The unit of time to use when calculating the Lower Bound value. 
        ///Possible values are None (the default), Second, Minute, Hour, Day, Month, and Year..
        /// </summary>
        internal static string RelativeDateTimeValidatorDataLowerUnitDescription {
            get {
                return ResourceManager.GetString("RelativeDateTimeValidatorDataLowerUnitDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Lower Bound Unit.
        /// </summary>
        internal static string RelativeDateTimeValidatorDataLowerUnitDisplayName {
            get {
                return ResourceManager.GetString("RelativeDateTimeValidatorDataLowerUnitDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The template to use when creating the validation message. 
        ///The template can contain placeholders for values exposed by the individual validation results for each member of the validated type. .
        /// </summary>
        internal static string RelativeDateTimeValidatorDataMessageTemplateDescription {
            get {
                return ResourceManager.GetString("RelativeDateTimeValidatorDataMessageTemplateDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Message Template.
        /// </summary>
        internal static string RelativeDateTimeValidatorDataMessageTemplateDisplayName {
            get {
                return ResourceManager.GetString("RelativeDateTimeValidatorDataMessageTemplateDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The key in an external resource file for the localized string to use as the validation message. .
        /// </summary>
        internal static string RelativeDateTimeValidatorDataMessageTemplateResourceNameDescription {
            get {
                return ResourceManager.GetString("RelativeDateTimeValidatorDataMessageTemplateResourceNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Name.
        /// </summary>
        internal static string RelativeDateTimeValidatorDataMessageTemplateResourceNameDisplayName {
            get {
                return ResourceManager.GetString("RelativeDateTimeValidatorDataMessageTemplateResourceNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type of the external resource file containing the localized string to use as the validation message. .
        /// </summary>
        internal static string RelativeDateTimeValidatorDataMessageTemplateResourceTypeNameDescription {
            get {
                return ResourceManager.GetString("RelativeDateTimeValidatorDataMessageTemplateResourceTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Type.
        /// </summary>
        internal static string RelativeDateTimeValidatorDataMessageTemplateResourceTypeNameDisplayName {
            get {
                return ResourceManager.GetString("RelativeDateTimeValidatorDataMessageTemplateResourceTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Relative Date Time Validator..
        /// </summary>
        internal static string RelativeDateTimeValidatorDataNameDescription {
            get {
                return ResourceManager.GetString("RelativeDateTimeValidatorDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string RelativeDateTimeValidatorDataNameDisplayName {
            get {
                return ResourceManager.GetString("RelativeDateTimeValidatorDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Reverses the validation behavior. When set to True, validation will fail (the validator will return False) 
        ///if the validation rules are satisfied, instead of the default behavior of failing when they are not satisfied. The default is False..
        /// </summary>
        internal static string RelativeDateTimeValidatorDataNegatedDescription {
            get {
                return ResourceManager.GetString("RelativeDateTimeValidatorDataNegatedDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Negated.
        /// </summary>
        internal static string RelativeDateTimeValidatorDataNegatedDisplayName {
            get {
                return ResourceManager.GetString("RelativeDateTimeValidatorDataNegatedDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A user-supplied string value that can be used to identify or classify the validator. 
        ///It can be accessed from code, and is typically used to sort or categorize the validation results. .
        /// </summary>
        internal static string RelativeDateTimeValidatorDataTagDescription {
            get {
                return ResourceManager.GetString("RelativeDateTimeValidatorDataTagDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tag.
        /// </summary>
        internal static string RelativeDateTimeValidatorDataTagDisplayName {
            get {
                return ResourceManager.GetString("RelativeDateTimeValidatorDataTagDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Relative Date Time Validator..
        /// </summary>
        internal static string RelativeDateTimeValidatorDataTypeNameDescription {
            get {
                return ResourceManager.GetString("RelativeDateTimeValidatorDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string RelativeDateTimeValidatorDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("RelativeDateTimeValidatorDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The number of a specific unit of time (such as days) after the date being validated. 
        ///The result is the maximum valid date and time..
        /// </summary>
        internal static string RelativeDateTimeValidatorDataUpperBoundDescription {
            get {
                return ResourceManager.GetString("RelativeDateTimeValidatorDataUpperBoundDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Upper Bound.
        /// </summary>
        internal static string RelativeDateTimeValidatorDataUpperBoundDisplayName {
            get {
                return ResourceManager.GetString("RelativeDateTimeValidatorDataUpperBoundDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Determines how to evaluate the Upper Bound value. 
        ///Ignore (the default) means that the validator ignores the Upper Bound value. Inclusive means that the validator allows values that are equal to the Upper Bound value. 
        ///Exclusive means that the validator does not allow values that are equal to the Upper Bound value..
        /// </summary>
        internal static string RelativeDateTimeValidatorDataUpperBoundTypeDescription {
            get {
                return ResourceManager.GetString("RelativeDateTimeValidatorDataUpperBoundTypeDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Upper Bound Type.
        /// </summary>
        internal static string RelativeDateTimeValidatorDataUpperBoundTypeDisplayName {
            get {
                return ResourceManager.GetString("RelativeDateTimeValidatorDataUpperBoundTypeDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The unit of time to use when calculating the Upper Bound value. Possible values are None (the default), Second, Minute, Hour, Day, Month, and Year..
        /// </summary>
        internal static string RelativeDateTimeValidatorDataUpperUnitDescription {
            get {
                return ResourceManager.GetString("RelativeDateTimeValidatorDataUpperUnitDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Upper Bound Unit.
        /// </summary>
        internal static string RelativeDateTimeValidatorDataUpperUnitDisplayName {
            get {
                return ResourceManager.GetString("RelativeDateTimeValidatorDataUpperUnitDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A validator that checks the length of the string is within a specified range. 
        ///The range may include or exclude the range endpoints by setting the lower or upper bounds and the types of these bounds..
        /// </summary>
        internal static string StringLengthValidatorDataDescription {
            get {
                return ResourceManager.GetString("StringLengthValidatorDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to String Length Validator.
        /// </summary>
        internal static string StringLengthValidatorDataDisplayName {
            get {
                return ResourceManager.GetString("StringLengthValidatorDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The minimum length of the validated string value..
        /// </summary>
        internal static string StringLengthValidatorDataLowerBoundDescription {
            get {
                return ResourceManager.GetString("StringLengthValidatorDataLowerBoundDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Lower Bound.
        /// </summary>
        internal static string StringLengthValidatorDataLowerBoundDisplayName {
            get {
                return ResourceManager.GetString("StringLengthValidatorDataLowerBoundDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Determines how to evaluate the Lower Bound value. 
        ///Ignore (the default) means that the validator ignores the Lower Bound value.
        ///Inclusive means that the validator allows values that are equal to the Lower Bound value. 
        ///Exclusive means that the validator does not allow values that are equal to the Lower Bound value..
        /// </summary>
        internal static string StringLengthValidatorDataLowerBoundTypeDescription {
            get {
                return ResourceManager.GetString("StringLengthValidatorDataLowerBoundTypeDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Lower Bound Type.
        /// </summary>
        internal static string StringLengthValidatorDataLowerBoundTypeDisplayName {
            get {
                return ResourceManager.GetString("StringLengthValidatorDataLowerBoundTypeDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The template to use when creating the validation message. 
        ///The template can contain placeholders for values exposed by the individual validation results for each member of the validated type. .
        /// </summary>
        internal static string StringLengthValidatorDataMessageTemplateDescription {
            get {
                return ResourceManager.GetString("StringLengthValidatorDataMessageTemplateDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Message Template.
        /// </summary>
        internal static string StringLengthValidatorDataMessageTemplateDisplayName {
            get {
                return ResourceManager.GetString("StringLengthValidatorDataMessageTemplateDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The key in an external resource file for the localized string to use as the validation message. .
        /// </summary>
        internal static string StringLengthValidatorDataMessageTemplateResourceNameDescription {
            get {
                return ResourceManager.GetString("StringLengthValidatorDataMessageTemplateResourceNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Name.
        /// </summary>
        internal static string StringLengthValidatorDataMessageTemplateResourceNameDisplayName {
            get {
                return ResourceManager.GetString("StringLengthValidatorDataMessageTemplateResourceNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type of the external resource file containing the localized string to use as the validation message. .
        /// </summary>
        internal static string StringLengthValidatorDataMessageTemplateResourceTypeNameDescription {
            get {
                return ResourceManager.GetString("StringLengthValidatorDataMessageTemplateResourceTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Type.
        /// </summary>
        internal static string StringLengthValidatorDataMessageTemplateResourceTypeNameDisplayName {
            get {
                return ResourceManager.GetString("StringLengthValidatorDataMessageTemplateResourceTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the String Length Validator..
        /// </summary>
        internal static string StringLengthValidatorDataNameDescription {
            get {
                return ResourceManager.GetString("StringLengthValidatorDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string StringLengthValidatorDataNameDisplayName {
            get {
                return ResourceManager.GetString("StringLengthValidatorDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Reverses the validation behavior. 
        ///When set to True, validation will fail (the validator will return False) if the validation rules are satisfied, instead of the default behavior of failing when they are not satisfied. 
        ///The default is False..
        /// </summary>
        internal static string StringLengthValidatorDataNegatedDescription {
            get {
                return ResourceManager.GetString("StringLengthValidatorDataNegatedDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Negated.
        /// </summary>
        internal static string StringLengthValidatorDataNegatedDisplayName {
            get {
                return ResourceManager.GetString("StringLengthValidatorDataNegatedDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A user-supplied string value that can be used to identify or classify the validator. 
        ///It can be accessed from code, and is typically used to sort or categorize the validation results. .
        /// </summary>
        internal static string StringLengthValidatorDataTagDescription {
            get {
                return ResourceManager.GetString("StringLengthValidatorDataTagDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tag.
        /// </summary>
        internal static string StringLengthValidatorDataTagDisplayName {
            get {
                return ResourceManager.GetString("StringLengthValidatorDataTagDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the String Length Validator..
        /// </summary>
        internal static string StringLengthValidatorDataTypeNameDescription {
            get {
                return ResourceManager.GetString("StringLengthValidatorDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string StringLengthValidatorDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("StringLengthValidatorDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The maximum length of the validated string value..
        /// </summary>
        internal static string StringLengthValidatorDataUpperBoundDescription {
            get {
                return ResourceManager.GetString("StringLengthValidatorDataUpperBoundDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Upper Bound.
        /// </summary>
        internal static string StringLengthValidatorDataUpperBoundDisplayName {
            get {
                return ResourceManager.GetString("StringLengthValidatorDataUpperBoundDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Determines how to evaluate the Upper Bound value. 
        ///Ignore (the default) means that the validator ignores the Upper Bound value. 
        ///Inclusive means that the validator allows values that are equal to the Upper Bound value. 
        ///Exclusive means that the validator does not allow values that are equal to the Upper Bound value..
        /// </summary>
        internal static string StringLengthValidatorDataUpperBoundTypeDescription {
            get {
                return ResourceManager.GetString("StringLengthValidatorDataUpperBoundTypeDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Upper Bound Type.
        /// </summary>
        internal static string StringLengthValidatorDataUpperBoundTypeDisplayName {
            get {
                return ResourceManager.GetString("StringLengthValidatorDataUpperBoundTypeDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A validator that checks if a string can be converted to a specific type. 
        ///For example, the validator can check that &apos;6.32&apos; can be converted to a Double type or that &apos;2007-02-09&apos; can be converted to a DateTime type..
        /// </summary>
        internal static string TypeConversionValidatorDataDescription {
            get {
                return ResourceManager.GetString("TypeConversionValidatorDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type Conversion Validator.
        /// </summary>
        internal static string TypeConversionValidatorDataDisplayName {
            get {
                return ResourceManager.GetString("TypeConversionValidatorDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The template to use when creating the validation message. 
        ///The template can contain placeholders for values exposed by the individual validation results for each member of the validated type. .
        /// </summary>
        internal static string TypeConversionValidatorDataMessageTemplateDescription {
            get {
                return ResourceManager.GetString("TypeConversionValidatorDataMessageTemplateDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Message Template.
        /// </summary>
        internal static string TypeConversionValidatorDataMessageTemplateDisplayName {
            get {
                return ResourceManager.GetString("TypeConversionValidatorDataMessageTemplateDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The key in an external resource file for the localized string to use as the validation message. .
        /// </summary>
        internal static string TypeConversionValidatorDataMessageTemplateResourceNameDescription {
            get {
                return ResourceManager.GetString("TypeConversionValidatorDataMessageTemplateResourceNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Name.
        /// </summary>
        internal static string TypeConversionValidatorDataMessageTemplateResourceNameDisplayName {
            get {
                return ResourceManager.GetString("TypeConversionValidatorDataMessageTemplateResourceNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type of the external resource file containing the localized string to use as the validation message. .
        /// </summary>
        internal static string TypeConversionValidatorDataMessageTemplateResourceTypeNameDescription {
            get {
                return ResourceManager.GetString("TypeConversionValidatorDataMessageTemplateResourceTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Type.
        /// </summary>
        internal static string TypeConversionValidatorDataMessageTemplateResourceTypeNameDisplayName {
            get {
                return ResourceManager.GetString("TypeConversionValidatorDataMessageTemplateResourceTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Type Conversion Validator..
        /// </summary>
        internal static string TypeConversionValidatorDataNameDescription {
            get {
                return ResourceManager.GetString("TypeConversionValidatorDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string TypeConversionValidatorDataNameDisplayName {
            get {
                return ResourceManager.GetString("TypeConversionValidatorDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Reverses the validation behavior. 
        ///When set to True, validation will fail (the validator will return False) if the validation rules are satisfied, instead of the default behavior of failing when they are not satisfied. The default is False..
        /// </summary>
        internal static string TypeConversionValidatorDataNegatedDescription {
            get {
                return ResourceManager.GetString("TypeConversionValidatorDataNegatedDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Negated.
        /// </summary>
        internal static string TypeConversionValidatorDataNegatedDisplayName {
            get {
                return ResourceManager.GetString("TypeConversionValidatorDataNegatedDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A user-supplied string value that can be used to identify or classify the validator. 
        ///It can be accessed from code, and is typically used to sort or categorize the validation results. .
        /// </summary>
        internal static string TypeConversionValidatorDataTagDescription {
            get {
                return ResourceManager.GetString("TypeConversionValidatorDataTagDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tag.
        /// </summary>
        internal static string TypeConversionValidatorDataTagDisplayName {
            get {
                return ResourceManager.GetString("TypeConversionValidatorDataTagDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the type to test conversion to..
        /// </summary>
        internal static string TypeConversionValidatorDataTargetTypeNameDescription {
            get {
                return ResourceManager.GetString("TypeConversionValidatorDataTargetTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Target Type.
        /// </summary>
        internal static string TypeConversionValidatorDataTargetTypeNameDisplayName {
            get {
                return ResourceManager.GetString("TypeConversionValidatorDataTargetTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Type Conversion Validator..
        /// </summary>
        internal static string TypeConversionValidatorDataTypeNameDescription {
            get {
                return ResourceManager.GetString("TypeConversionValidatorDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string TypeConversionValidatorDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("TypeConversionValidatorDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collection of fields being validated for this type..
        /// </summary>
        internal static string ValidatedFieldReferenceCollectionDescription {
            get {
                return ResourceManager.GetString("ValidatedFieldReferenceCollectionDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Validated Field Reference Collection.
        /// </summary>
        internal static string ValidatedFieldReferenceCollectionDisplayName {
            get {
                return ResourceManager.GetString("ValidatedFieldReferenceCollectionDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A field within the type that will be validated by this rule set..
        /// </summary>
        internal static string ValidatedFieldReferenceDescription {
            get {
                return ResourceManager.GetString("ValidatedFieldReferenceDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Field To Validate.
        /// </summary>
        internal static string ValidatedFieldReferenceDisplayName {
            get {
                return ResourceManager.GetString("ValidatedFieldReferenceDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Validated Field Reference..
        /// </summary>
        internal static string ValidatedFieldReferenceNameDescription {
            get {
                return ResourceManager.GetString("ValidatedFieldReferenceNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string ValidatedFieldReferenceNameDisplayName {
            get {
                return ResourceManager.GetString("ValidatedFieldReferenceNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collection of validators configured for this field of the type being validated..
        /// </summary>
        internal static string ValidatedFieldReferenceValidatorsDescription {
            get {
                return ResourceManager.GetString("ValidatedFieldReferenceValidatorsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Validators.
        /// </summary>
        internal static string ValidatedFieldReferenceValidatorsDisplayName {
            get {
                return ResourceManager.GetString("ValidatedFieldReferenceValidatorsDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A member of the type that will be validated..
        /// </summary>
        internal static string ValidatedMemberReferenceDescription {
            get {
                return ResourceManager.GetString("ValidatedMemberReferenceDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Validated Member.
        /// </summary>
        internal static string ValidatedMemberReferenceDisplayName {
            get {
                return ResourceManager.GetString("ValidatedMemberReferenceDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Validated Member..
        /// </summary>
        internal static string ValidatedMemberReferenceNameDescription {
            get {
                return ResourceManager.GetString("ValidatedMemberReferenceNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string ValidatedMemberReferenceNameDisplayName {
            get {
                return ResourceManager.GetString("ValidatedMemberReferenceNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collection of validators configured for the member of the type being validated..
        /// </summary>
        internal static string ValidatedMemberReferenceValidatorsDescription {
            get {
                return ResourceManager.GetString("ValidatedMemberReferenceValidatorsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Validators.
        /// </summary>
        internal static string ValidatedMemberReferenceValidatorsDisplayName {
            get {
                return ResourceManager.GetString("ValidatedMemberReferenceValidatorsDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collection of methods being validated for this type..
        /// </summary>
        internal static string ValidatedMethodReferenceCollectionDescription {
            get {
                return ResourceManager.GetString("ValidatedMethodReferenceCollectionDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Validated Method Reference Collection.
        /// </summary>
        internal static string ValidatedMethodReferenceCollectionDisplayName {
            get {
                return ResourceManager.GetString("ValidatedMethodReferenceCollectionDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A method within the type whose return value will be validated by this rule set..
        /// </summary>
        internal static string ValidatedMethodReferenceDescription {
            get {
                return ResourceManager.GetString("ValidatedMethodReferenceDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Method To Validate.
        /// </summary>
        internal static string ValidatedMethodReferenceDisplayName {
            get {
                return ResourceManager.GetString("ValidatedMethodReferenceDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the method to validate..
        /// </summary>
        internal static string ValidatedMethodReferenceNameDescription {
            get {
                return ResourceManager.GetString("ValidatedMethodReferenceNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string ValidatedMethodReferenceNameDisplayName {
            get {
                return ResourceManager.GetString("ValidatedMethodReferenceNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collection of validators configured for this method of the type being validated..
        /// </summary>
        internal static string ValidatedMethodReferenceValidatorsDescription {
            get {
                return ResourceManager.GetString("ValidatedMethodReferenceValidatorsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Validators.
        /// </summary>
        internal static string ValidatedMethodReferenceValidatorsDisplayName {
            get {
                return ResourceManager.GetString("ValidatedMethodReferenceValidatorsDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collection of properties being validated for this type..
        /// </summary>
        internal static string ValidatedPropertyReferenceCollectionDescription {
            get {
                return ResourceManager.GetString("ValidatedPropertyReferenceCollectionDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Validated Property Reference Collection.
        /// </summary>
        internal static string ValidatedPropertyReferenceCollectionDisplayName {
            get {
                return ResourceManager.GetString("ValidatedPropertyReferenceCollectionDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A property within the type whose value will be validated by this rule set..
        /// </summary>
        internal static string ValidatedPropertyReferenceDescription {
            get {
                return ResourceManager.GetString("ValidatedPropertyReferenceDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Property To Validate.
        /// </summary>
        internal static string ValidatedPropertyReferenceDisplayName {
            get {
                return ResourceManager.GetString("ValidatedPropertyReferenceDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the property to validate..
        /// </summary>
        internal static string ValidatedPropertyReferenceNameDescription {
            get {
                return ResourceManager.GetString("ValidatedPropertyReferenceNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string ValidatedPropertyReferenceNameDisplayName {
            get {
                return ResourceManager.GetString("ValidatedPropertyReferenceNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collection of validators configured for this property of the type being validated..
        /// </summary>
        internal static string ValidatedPropertyReferenceValidatorsDescription {
            get {
                return ResourceManager.GetString("ValidatedPropertyReferenceValidatorsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Validators.
        /// </summary>
        internal static string ValidatedPropertyReferenceValidatorsDisplayName {
            get {
                return ResourceManager.GetString("ValidatedPropertyReferenceValidatorsDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar used to resolve the reference type at design time. This property is ignored at runtime..
        /// </summary>
        internal static string ValidatedTypeReferenceAssemblyNameDescription {
            get {
                return ResourceManager.GetString("ValidatedTypeReferenceAssemblyNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Assembly Name.
        /// </summary>
        internal static string ValidatedTypeReferenceAssemblyNameDisplayName {
            get {
                return ResourceManager.GetString("ValidatedTypeReferenceAssemblyNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collection of validation rulesets configured this type..
        /// </summary>
        internal static string ValidatedTypeReferenceCollectionDescription {
            get {
                return ResourceManager.GetString("ValidatedTypeReferenceCollectionDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Validated Type Reference Collection.
        /// </summary>
        internal static string ValidatedTypeReferenceCollectionDisplayName {
            get {
                return ResourceManager.GetString("ValidatedTypeReferenceCollectionDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The Ruleset to use when validating the type when code does not specify the name of a configured Ruleset..
        /// </summary>
        internal static string ValidatedTypeReferenceDefaultRulesetDescription {
            get {
                return ResourceManager.GetString("ValidatedTypeReferenceDefaultRulesetDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Default Ruleset.
        /// </summary>
        internal static string ValidatedTypeReferenceDefaultRulesetDisplayName {
            get {
                return ResourceManager.GetString("ValidatedTypeReferenceDefaultRulesetDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The class or type whose members will be validated by the Validation Application Block.
        /// </summary>
        internal static string ValidatedTypeReferenceDescription {
            get {
                return ResourceManager.GetString("ValidatedTypeReferenceDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type To Validate.
        /// </summary>
        internal static string ValidatedTypeReferenceDisplayName {
            get {
                return ResourceManager.GetString("ValidatedTypeReferenceDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the type to be validated..
        /// </summary>
        internal static string ValidatedTypeReferenceNameDescription {
            get {
                return ResourceManager.GetString("ValidatedTypeReferenceNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string ValidatedTypeReferenceNameDisplayName {
            get {
                return ResourceManager.GetString("ValidatedTypeReferenceNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collection of validation rulesets configured this type..
        /// </summary>
        internal static string ValidatedTypeReferenceRulesetsDescription {
            get {
                return ResourceManager.GetString("ValidatedTypeReferenceRulesetsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Rule Sets.
        /// </summary>
        internal static string ValidatedTypeReferenceRulesetsDisplayName {
            get {
                return ResourceManager.GetString("ValidatedTypeReferenceRulesetsDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A Call Handler that provides the capability to test whether the value provided for the selected property, or the values specified for the parameters of the selected method, are valid against specific rules. 
        ///This handler uses the Validation Application Block to perform the validation..
        /// </summary>
        internal static string ValidationCallHandlerDataDescription {
            get {
                return ResourceManager.GetString("ValidationCallHandlerDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Validation Call Handler.
        /// </summary>
        internal static string ValidationCallHandlerDataDisplayName {
            get {
                return ResourceManager.GetString("ValidationCallHandlerDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Validation Call Handler..
        /// </summary>
        internal static string ValidationCallHandlerDataNameDescription {
            get {
                return ResourceManager.GetString("ValidationCallHandlerDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string ValidationCallHandlerDataNameDisplayName {
            get {
                return ResourceManager.GetString("ValidationCallHandlerDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The position of the handler within the policy handler chain, starting from 1. 
        ///The default value is zero, which means that there is no explicit order specified for the handler in relation to other handlers in the same handler chain..
        /// </summary>
        internal static string ValidationCallHandlerDataOrderDescription {
            get {
                return ResourceManager.GetString("ValidationCallHandlerDataOrderDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Order.
        /// </summary>
        internal static string ValidationCallHandlerDataOrderDisplayName {
            get {
                return ResourceManager.GetString("ValidationCallHandlerDataOrderDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the rule set to use for all target object types, as configured in the Validation Application Block. 
        ///An empty string causes the handler to use the default rule set..
        /// </summary>
        internal static string ValidationCallHandlerDataRuleSetDescription {
            get {
                return ResourceManager.GetString("ValidationCallHandlerDataRuleSetDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Rule Set.
        /// </summary>
        internal static string ValidationCallHandlerDataRuleSetDisplayName {
            get {
                return ResourceManager.GetString("ValidationCallHandlerDataRuleSetDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A value from the SpecificationSource enumeration that defines the locations where the handler will look for validation rules. 
        ///Valid values are Attributes, Configuration, ParameterAttributesOnly, and Both..
        /// </summary>
        internal static string ValidationCallHandlerDataSpecificationSourceDescription {
            get {
                return ResourceManager.GetString("ValidationCallHandlerDataSpecificationSourceDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Rule Source.
        /// </summary>
        internal static string ValidationCallHandlerDataSpecificationSourceDisplayName {
            get {
                return ResourceManager.GetString("ValidationCallHandlerDataSpecificationSourceDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Validation Call Handler..
        /// </summary>
        internal static string ValidationCallHandlerDataTypeNameDescription {
            get {
                return ResourceManager.GetString("ValidationCallHandlerDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string ValidationCallHandlerDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("ValidationCallHandlerDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A collection of validated properties..
        /// </summary>
        internal static string ValidationRulesetDataCollectionDescription {
            get {
                return ResourceManager.GetString("ValidationRulesetDataCollectionDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Validation Ruleset Data Collection.
        /// </summary>
        internal static string ValidationRulesetDataCollectionDisplayName {
            get {
                return ResourceManager.GetString("ValidationRulesetDataCollectionDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A set of validation rules to apply when validating instances of this type..
        /// </summary>
        internal static string ValidationRulesetDataDescription {
            get {
                return ResourceManager.GetString("ValidationRulesetDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Validation Ruleset.
        /// </summary>
        internal static string ValidationRulesetDataDisplayName {
            get {
                return ResourceManager.GetString("ValidationRulesetDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collection of fields that will be validated within the type that owns this ruleset..
        /// </summary>
        internal static string ValidationRulesetDataFieldsDescription {
            get {
                return ResourceManager.GetString("ValidationRulesetDataFieldsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Fields.
        /// </summary>
        internal static string ValidationRulesetDataFieldsDisplayName {
            get {
                return ResourceManager.GetString("ValidationRulesetDataFieldsDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collection of methods whose return values will be validated within the type that owns this ruleset..
        /// </summary>
        internal static string ValidationRulesetDataMethodsDescription {
            get {
                return ResourceManager.GetString("ValidationRulesetDataMethodsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Methods.
        /// </summary>
        internal static string ValidationRulesetDataMethodsDisplayName {
            get {
                return ResourceManager.GetString("ValidationRulesetDataMethodsDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Validation Ruleset..
        /// </summary>
        internal static string ValidationRulesetDataNameDescription {
            get {
                return ResourceManager.GetString("ValidationRulesetDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string ValidationRulesetDataNameDisplayName {
            get {
                return ResourceManager.GetString("ValidationRulesetDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collection of properties that will be validated within the type that owns this ruleset..
        /// </summary>
        internal static string ValidationRulesetDataPropertiesDescription {
            get {
                return ResourceManager.GetString("ValidationRulesetDataPropertiesDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Properties.
        /// </summary>
        internal static string ValidationRulesetDataPropertiesDisplayName {
            get {
                return ResourceManager.GetString("ValidationRulesetDataPropertiesDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collection of validators defined for the type that owns this ruleset..
        /// </summary>
        internal static string ValidationRulesetDataValidatorsDescription {
            get {
                return ResourceManager.GetString("ValidationRulesetDataValidatorsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Validators.
        /// </summary>
        internal static string ValidationRulesetDataValidatorsDisplayName {
            get {
                return ResourceManager.GetString("ValidationRulesetDataValidatorsDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Configuration settings for the Validation Application Block..
        /// </summary>
        internal static string ValidationSettingsDescription {
            get {
                return ResourceManager.GetString("ValidationSettingsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Validation Settings.
        /// </summary>
        internal static string ValidationSettingsDisplayName {
            get {
                return ResourceManager.GetString("ValidationSettingsDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The types or classes whose members will be validated by the rules sets defined in the configuration..
        /// </summary>
        internal static string ValidationSettingsTypesDescription {
            get {
                return ResourceManager.GetString("ValidationSettingsTypesDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Validated Types.
        /// </summary>
        internal static string ValidationSettingsTypesDisplayName {
            get {
                return ResourceManager.GetString("ValidationSettingsTypesDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A collection of validators..
        /// </summary>
        internal static string ValidatorDataCollectionDescription {
            get {
                return ResourceManager.GetString("ValidatorDataCollectionDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Validator Data Collection.
        /// </summary>
        internal static string ValidatorDataCollectionDisplayName {
            get {
                return ResourceManager.GetString("ValidatorDataCollectionDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Base class for all Validators..
        /// </summary>
        internal static string ValidatorDataDescription {
            get {
                return ResourceManager.GetString("ValidatorDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Validator.
        /// </summary>
        internal static string ValidatorDataDisplayName {
            get {
                return ResourceManager.GetString("ValidatorDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The template to use when creating the validation message. 
        ///The template can contain placeholders for values exposed by the individual validation results for each member of the validated type. .
        /// </summary>
        internal static string ValidatorDataMessageTemplateDescription {
            get {
                return ResourceManager.GetString("ValidatorDataMessageTemplateDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Message Template.
        /// </summary>
        internal static string ValidatorDataMessageTemplateDisplayName {
            get {
                return ResourceManager.GetString("ValidatorDataMessageTemplateDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The key in an external resource file for the localized string to use as the validation message. .
        /// </summary>
        internal static string ValidatorDataMessageTemplateResourceNameDescription {
            get {
                return ResourceManager.GetString("ValidatorDataMessageTemplateResourceNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Name.
        /// </summary>
        internal static string ValidatorDataMessageTemplateResourceNameDisplayName {
            get {
                return ResourceManager.GetString("ValidatorDataMessageTemplateResourceNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type of the external resource file containing the localized string to use as the validation message. .
        /// </summary>
        internal static string ValidatorDataMessageTemplateResourceTypeNameDescription {
            get {
                return ResourceManager.GetString("ValidatorDataMessageTemplateResourceTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Type.
        /// </summary>
        internal static string ValidatorDataMessageTemplateResourceTypeNameDisplayName {
            get {
                return ResourceManager.GetString("ValidatorDataMessageTemplateResourceTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Validator..
        /// </summary>
        internal static string ValidatorDataNameDescription {
            get {
                return ResourceManager.GetString("ValidatorDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string ValidatorDataNameDisplayName {
            get {
                return ResourceManager.GetString("ValidatorDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A user-supplied string value that can be used to identify or classify the validator. 
        ///It can be accessed from code, and is typically used to sort or categorize the validation results. .
        /// </summary>
        internal static string ValidatorDataTagDescription {
            get {
                return ResourceManager.GetString("ValidatorDataTagDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tag.
        /// </summary>
        internal static string ValidatorDataTagDisplayName {
            get {
                return ResourceManager.GetString("ValidatorDataTagDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Validator..
        /// </summary>
        internal static string ValidatorDataTypeNameDescription {
            get {
                return ResourceManager.GetString("ValidatorDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type Name.
        /// </summary>
        internal static string ValidatorDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("ValidatorDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A Validator that validates against defined values..
        /// </summary>
        internal static string ValueValidatorDataDescription {
            get {
                return ResourceManager.GetString("ValueValidatorDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Value Validator.
        /// </summary>
        internal static string ValueValidatorDataDisplayName {
            get {
                return ResourceManager.GetString("ValueValidatorDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The template to use when creating the validation message. 
        ///The template can contain placeholders for values exposed by the individual validation results for each member of the validated type. .
        /// </summary>
        internal static string ValueValidatorDataMessageTemplateDescription {
            get {
                return ResourceManager.GetString("ValueValidatorDataMessageTemplateDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Message Template.
        /// </summary>
        internal static string ValueValidatorDataMessageTemplateDisplayName {
            get {
                return ResourceManager.GetString("ValueValidatorDataMessageTemplateDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The key in an external resource file for the localized string to use as the validation message. .
        /// </summary>
        internal static string ValueValidatorDataMessageTemplateResourceNameDescription {
            get {
                return ResourceManager.GetString("ValueValidatorDataMessageTemplateResourceNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Name.
        /// </summary>
        internal static string ValueValidatorDataMessageTemplateResourceNameDisplayName {
            get {
                return ResourceManager.GetString("ValueValidatorDataMessageTemplateResourceNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type of the external resource file containing the localized string to use as the validation message. .
        /// </summary>
        internal static string ValueValidatorDataMessageTemplateResourceTypeNameDescription {
            get {
                return ResourceManager.GetString("ValueValidatorDataMessageTemplateResourceTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template Resource Type.
        /// </summary>
        internal static string ValueValidatorDataMessageTemplateResourceTypeNameDisplayName {
            get {
                return ResourceManager.GetString("ValueValidatorDataMessageTemplateResourceTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Validator..
        /// </summary>
        internal static string ValueValidatorDataNameDescription {
            get {
                return ResourceManager.GetString("ValueValidatorDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string ValueValidatorDataNameDisplayName {
            get {
                return ResourceManager.GetString("ValueValidatorDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Reverses the validation behavior. 
        ///When set to True, validation will fail (the validator will return False) if the validation rules are satisfied, instead of the default behavior of failing when they are not satisfied. The default is False..
        /// </summary>
        internal static string ValueValidatorDataNegatedDescription {
            get {
                return ResourceManager.GetString("ValueValidatorDataNegatedDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Negated.
        /// </summary>
        internal static string ValueValidatorDataNegatedDisplayName {
            get {
                return ResourceManager.GetString("ValueValidatorDataNegatedDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A user-supplied string value that can be used to identify or classify the validator. 
        ///It can be accessed from code, and is typically used to sort or categorize the validation results. .
        /// </summary>
        internal static string ValueValidatorDataTagDescription {
            get {
                return ResourceManager.GetString("ValueValidatorDataTagDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tag.
        /// </summary>
        internal static string ValueValidatorDataTagDisplayName {
            get {
                return ResourceManager.GetString("ValueValidatorDataTagDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Validator..
        /// </summary>
        internal static string ValueValidatorDataTypeNameDescription {
            get {
                return ResourceManager.GetString("ValueValidatorDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string ValueValidatorDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("ValueValidatorDataTypeNameDisplayName", resourceCulture);
            }
        }
    }
}
