//===============================================================================
// Microsoft patterns & practices Enterprise Library
// Policy Injection 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.PolicyInjection.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.PolicyInjection.Configuration.DesignResourc" +
                            "es", 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 Policy Injection Settings.
        /// </summary>
        internal static string AddPolicyInjectionSettings {
            get {
                return ResourceManager.GetString("AddPolicyInjectionSettings", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A Matching Rule that selects target classes based on the assembly name or by specifying a reference to an assembly..
        /// </summary>
        internal static string AssemblyMatchingRuleDataDescription {
            get {
                return ResourceManager.GetString("AssemblyMatchingRuleDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Assembly Matching Rule.
        /// </summary>
        internal static string AssemblyMatchingRuleDataDisplayName {
            get {
                return ResourceManager.GetString("AssemblyMatchingRuleDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the assembly to match. 
        ///It can be the name and version; the name, version and culture; or the full assembly name of the assembly excluding the .dll file name extension. 
        ///It cannot include wildcard characters. .
        /// </summary>
        internal static string AssemblyMatchingRuleDataMatchDescription {
            get {
                return ResourceManager.GetString("AssemblyMatchingRuleDataMatchDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Assembly Name.
        /// </summary>
        internal static string AssemblyMatchingRuleDataMatchDisplayName {
            get {
                return ResourceManager.GetString("AssemblyMatchingRuleDataMatchDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Assembly Matching Rule..
        /// </summary>
        internal static string AssemblyMatchingRuleDataNameDescription {
            get {
                return ResourceManager.GetString("AssemblyMatchingRuleDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string AssemblyMatchingRuleDataNameDisplayName {
            get {
                return ResourceManager.GetString("AssemblyMatchingRuleDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Assembly Matching Rule..
        /// </summary>
        internal static string AssemblyMatchingRuleDataTypeNameDescription {
            get {
                return ResourceManager.GetString("AssemblyMatchingRuleDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string AssemblyMatchingRuleDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("AssemblyMatchingRuleDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type name of the custom attribute that is applied to members of the target object..
        /// </summary>
        internal static string CustomAttributeMatchingRuleDataAttributeTypeNameDescription {
            get {
                return ResourceManager.GetString("CustomAttributeMatchingRuleDataAttributeTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Attribute Type Name.
        /// </summary>
        internal static string CustomAttributeMatchingRuleDataAttributeTypeNameDisplayName {
            get {
                return ResourceManager.GetString("CustomAttributeMatchingRuleDataAttributeTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A Matching Rule that selects target classes and class members based on a custom attribute type that is applied to class members..
        /// </summary>
        internal static string CustomAttributeMatchingRuleDataDescription {
            get {
                return ResourceManager.GetString("CustomAttributeMatchingRuleDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Attribute Matching Rule.
        /// </summary>
        internal static string CustomAttributeMatchingRuleDataDisplayName {
            get {
                return ResourceManager.GetString("CustomAttributeMatchingRuleDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Custom Attribute Matching Rule..
        /// </summary>
        internal static string CustomAttributeMatchingRuleDataNameDescription {
            get {
                return ResourceManager.GetString("CustomAttributeMatchingRuleDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string CustomAttributeMatchingRuleDataNameDisplayName {
            get {
                return ResourceManager.GetString("CustomAttributeMatchingRuleDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies whether the rule should also search base classes for members that carry the custom attribute..
        /// </summary>
        internal static string CustomAttributeMatchingRuleDataSearchInheritanceChainDescription {
            get {
                return ResourceManager.GetString("CustomAttributeMatchingRuleDataSearchInheritanceChainDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Search Inheritance Chain.
        /// </summary>
        internal static string CustomAttributeMatchingRuleDataSearchInheritanceChainDisplayName {
            get {
                return ResourceManager.GetString("CustomAttributeMatchingRuleDataSearchInheritanceChainDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Custom Attribute Matching Rule..
        /// </summary>
        internal static string CustomAttributeMatchingRuleDataTypeNameDescription {
            get {
                return ResourceManager.GetString("CustomAttributeMatchingRuleDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string CustomAttributeMatchingRuleDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("CustomAttributeMatchingRuleDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Matching Rule (using type picker).
        /// </summary>
        internal static string CustomMatchingRuleDataAddCommand {
            get {
                return ResourceManager.GetString("CustomMatchingRuleDataAddCommand", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A custom implementation of a Matching Rule that is added to Enterprise Library..
        /// </summary>
        internal static string CustomMatchingRuleDataDescription {
            get {
                return ResourceManager.GetString("CustomMatchingRuleDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Matching Rule.
        /// </summary>
        internal static string CustomMatchingRuleDataDisplayName {
            get {
                return ResourceManager.GetString("CustomMatchingRuleDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Custom Matching Rule..
        /// </summary>
        internal static string CustomMatchingRuleDataNameDescription {
            get {
                return ResourceManager.GetString("CustomMatchingRuleDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string CustomMatchingRuleDataNameDisplayName {
            get {
                return ResourceManager.GetString("CustomMatchingRuleDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Custom Matching Rule..
        /// </summary>
        internal static string CustomMatchingRuleDataTypeNameDescription {
            get {
                return ResourceManager.GetString("CustomMatchingRuleDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string CustomMatchingRuleDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("CustomMatchingRuleDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A collection of matches for a Matching Rule..
        /// </summary>
        internal static string MatchDataCollectionDescription {
            get {
                return ResourceManager.GetString("MatchDataCollectionDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Match Data Collection.
        /// </summary>
        internal static string MatchDataCollectionDisplayName {
            get {
                return ResourceManager.GetString("MatchDataCollectionDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A class that holds information about a single match for a Matching Rule, such as the string to match and whether the match is case-sensitive..
        /// </summary>
        internal static string MatchDataDescription {
            get {
                return ResourceManager.GetString("MatchDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Match.
        /// </summary>
        internal static string MatchDataDisplayName {
            get {
                return ResourceManager.GetString("MatchDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies whether the match should be carried out on a case-sensitive basis. 
        ///The default is false..
        /// </summary>
        internal static string MatchDataIgnoreCaseDescription {
            get {
                return ResourceManager.GetString("MatchDataIgnoreCaseDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Ignore Case.
        /// </summary>
        internal static string MatchDataIgnoreCaseDisplayName {
            get {
                return ResourceManager.GetString("MatchDataIgnoreCaseDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The string value the Matching Rule will compare to class, member, or parameter names..
        /// </summary>
        internal static string MatchDataMatchDescription {
            get {
                return ResourceManager.GetString("MatchDataMatchDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Match.
        /// </summary>
        internal static string MatchDataMatchDisplayName {
            get {
                return ResourceManager.GetString("MatchDataMatchDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A base class for all Matching Rules..
        /// </summary>
        internal static string MatchingRuleDataDescription {
            get {
                return ResourceManager.GetString("MatchingRuleDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Matching Rule.
        /// </summary>
        internal static string MatchingRuleDataDisplayName {
            get {
                return ResourceManager.GetString("MatchingRuleDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Matching Rule..
        /// </summary>
        internal static string MatchingRuleDataNameDescription {
            get {
                return ResourceManager.GetString("MatchingRuleDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string MatchingRuleDataNameDisplayName {
            get {
                return ResourceManager.GetString("MatchingRuleDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Matching Rule..
        /// </summary>
        internal static string MatchingRuleDataTypeNameDescription {
            get {
                return ResourceManager.GetString("MatchingRuleDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string MatchingRuleDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("MatchingRuleDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A Matching Rule that selects target classes and class members based on the names of the class members (methods or properties). 
        ///Wildcard characters can be used for the member name..
        /// </summary>
        internal static string MemberNameMatchingRuleDataDescription {
            get {
                return ResourceManager.GetString("MemberNameMatchingRuleDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Member Name Matching Rule.
        /// </summary>
        internal static string MemberNameMatchingRuleDataDisplayName {
            get {
                return ResourceManager.GetString("MemberNameMatchingRuleDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collection of method and property names to match. 
        ///Wildcard characters can be included..
        /// </summary>
        internal static string MemberNameMatchingRuleDataMatchesDescription {
            get {
                return ResourceManager.GetString("MemberNameMatchingRuleDataMatchesDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Member Names.
        /// </summary>
        internal static string MemberNameMatchingRuleDataMatchesDisplayName {
            get {
                return ResourceManager.GetString("MemberNameMatchingRuleDataMatchesDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Member Name Matching Rule..
        /// </summary>
        internal static string MemberNameMatchingRuleDataNameDescription {
            get {
                return ResourceManager.GetString("MemberNameMatchingRuleDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string MemberNameMatchingRuleDataNameDisplayName {
            get {
                return ResourceManager.GetString("MemberNameMatchingRuleDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Member Name Matching Rule..
        /// </summary>
        internal static string MemberNameMatchingRuleDataTypeNameDescription {
            get {
                return ResourceManager.GetString("MemberNameMatchingRuleDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string MemberNameMatchingRuleDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("MemberNameMatchingRuleDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A Matching Rule that selects target classes and class members based on the name and signature (the list of parameter types) of its members. 
        ///This rule allows the use of wildcard characters for the member names..
        /// </summary>
        internal static string MethodSignatureMatchingRuleDataDescription {
            get {
                return ResourceManager.GetString("MethodSignatureMatchingRuleDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Method Signature Matching Rule.
        /// </summary>
        internal static string MethodSignatureMatchingRuleDataDisplayName {
            get {
                return ResourceManager.GetString("MethodSignatureMatchingRuleDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies whether the match should be carried out on a case-sensitive basis. The default is false..
        /// </summary>
        internal static string MethodSignatureMatchingRuleDataIgnoreCaseDescription {
            get {
                return ResourceManager.GetString("MethodSignatureMatchingRuleDataIgnoreCaseDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Ignore Case.
        /// </summary>
        internal static string MethodSignatureMatchingRuleDataIgnoreCaseDisplayName {
            get {
                return ResourceManager.GetString("MethodSignatureMatchingRuleDataIgnoreCaseDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the method to match. Wildcard characters can be included..
        /// </summary>
        internal static string MethodSignatureMatchingRuleDataMatchDescription {
            get {
                return ResourceManager.GetString("MethodSignatureMatchingRuleDataMatchDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Method Name.
        /// </summary>
        internal static string MethodSignatureMatchingRuleDataMatchDisplayName {
            get {
                return ResourceManager.GetString("MethodSignatureMatchingRuleDataMatchDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Method Signature Matching Rule..
        /// </summary>
        internal static string MethodSignatureMatchingRuleDataNameDescription {
            get {
                return ResourceManager.GetString("MethodSignatureMatchingRuleDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string MethodSignatureMatchingRuleDataNameDisplayName {
            get {
                return ResourceManager.GetString("MethodSignatureMatchingRuleDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collection of parameter type names (not the parameter names) that make up the matching method signature..
        /// </summary>
        internal static string MethodSignatureMatchingRuleDataParametersDescription {
            get {
                return ResourceManager.GetString("MethodSignatureMatchingRuleDataParametersDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Parameters.
        /// </summary>
        internal static string MethodSignatureMatchingRuleDataParametersDisplayName {
            get {
                return ResourceManager.GetString("MethodSignatureMatchingRuleDataParametersDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Method Signature Matching Rule..
        /// </summary>
        internal static string MethodSignatureMatchingRuleDataTypeNameDescription {
            get {
                return ResourceManager.GetString("MethodSignatureMatchingRuleDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string MethodSignatureMatchingRuleDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("MethodSignatureMatchingRuleDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A Matching Rule that selects target classes and class members based on their namespace name, using wildcard characters for the child namespace names but not for the root namespace name..
        /// </summary>
        internal static string NamespaceMatchingRuleDataDescription {
            get {
                return ResourceManager.GetString("NamespaceMatchingRuleDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Namespace Matching Rule.
        /// </summary>
        internal static string NamespaceMatchingRuleDataDisplayName {
            get {
                return ResourceManager.GetString("NamespaceMatchingRuleDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collection of namespaces to match. 
        ///Wildcard characters can be used for the child namespace names but not for the root namespace name..
        /// </summary>
        internal static string NamespaceMatchingRuleDataMatchesDescription {
            get {
                return ResourceManager.GetString("NamespaceMatchingRuleDataMatchesDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Namespaces.
        /// </summary>
        internal static string NamespaceMatchingRuleDataMatchesDisplayName {
            get {
                return ResourceManager.GetString("NamespaceMatchingRuleDataMatchesDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Namespace Matching Rule..
        /// </summary>
        internal static string NamespaceMatchingRuleDataNameDescription {
            get {
                return ResourceManager.GetString("NamespaceMatchingRuleDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string NamespaceMatchingRuleDataNameDisplayName {
            get {
                return ResourceManager.GetString("NamespaceMatchingRuleDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Namespace Matching Rule..
        /// </summary>
        internal static string NamespaceMatchingRuleDataTypeNameDescription {
            get {
                return ResourceManager.GetString("NamespaceMatchingRuleDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string NamespaceMatchingRuleDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("NamespaceMatchingRuleDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collection of parameter types to match. 
        ///The type name can be a fully qualified type name or just the class name. Each match also specifies whether the match
        ///is case-sensitive, and the parameter kind (which must be one of Input, Output, InputOrOutput, and ReturnValue)..
        /// </summary>
        internal static string ParameterTypeElementDataCollectionDescription {
            get {
                return ResourceManager.GetString("ParameterTypeElementDataCollectionDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Parameter Type Element Data Collection.
        /// </summary>
        internal static string ParameterTypeElementDataCollectionDisplayName {
            get {
                return ResourceManager.GetString("ParameterTypeElementDataCollectionDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type name, case-sensitivity, and usage for an individual parameter type to match. 
        ///The type name can be a fully qualified type name or just the class name..
        /// </summary>
        internal static string ParameterTypeElementDescription {
            get {
                return ResourceManager.GetString("ParameterTypeElementDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Parameter Type Element.
        /// </summary>
        internal static string ParameterTypeElementDisplayName {
            get {
                return ResourceManager.GetString("ParameterTypeElementDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A unique ID for this parameter. 
        ///This name does not need to match the corresponding parameter in the target types; only the type is used..
        /// </summary>
        internal static string ParameterTypeElementNameDescription {
            get {
                return ResourceManager.GetString("ParameterTypeElementNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string ParameterTypeElementNameDisplayName {
            get {
                return ResourceManager.GetString("ParameterTypeElementNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An individual parameter type to match. The type name can be a fully qualified type name or just the class name..
        /// </summary>
        internal static string ParameterTypeElementParameterTypeNameDescription {
            get {
                return ResourceManager.GetString("ParameterTypeElementParameterTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Parameter Type Name.
        /// </summary>
        internal static string ParameterTypeElementParameterTypeNameDisplayName {
            get {
                return ResourceManager.GetString("ParameterTypeElementParameterTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type name, case-sensitivity, and usage for an individual parameter type to match. 
        ///The type name can be a fully qualified type name or just the class name..
        /// </summary>
        internal static string ParameterTypeMatchDataDescription {
            get {
                return ResourceManager.GetString("ParameterTypeMatchDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Parameter Type Match.
        /// </summary>
        internal static string ParameterTypeMatchDataDisplayName {
            get {
                return ResourceManager.GetString("ParameterTypeMatchDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies whether the match should be carried out on a case-sensitive basis. The default is false..
        /// </summary>
        internal static string ParameterTypeMatchDataIgnoreCaseDescription {
            get {
                return ResourceManager.GetString("ParameterTypeMatchDataIgnoreCaseDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Ignore Case.
        /// </summary>
        internal static string ParameterTypeMatchDataIgnoreCaseDisplayName {
            get {
                return ResourceManager.GetString("ParameterTypeMatchDataIgnoreCaseDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An individual parameter type to match. The type name can be a fully qualified type name or just the class name..
        /// </summary>
        internal static string ParameterTypeMatchDataMatchDescription {
            get {
                return ResourceManager.GetString("ParameterTypeMatchDataMatchDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Parameter Type.
        /// </summary>
        internal static string ParameterTypeMatchDataMatchDisplayName {
            get {
                return ResourceManager.GetString("ParameterTypeMatchDataMatchDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The usage of the parameter as a value from the ParameterKind enumeration. 
        ///Valid values are Input, Output, InputOrOutput, and ReturnValue..
        /// </summary>
        internal static string ParameterTypeMatchDataParameterKindDescription {
            get {
                return ResourceManager.GetString("ParameterTypeMatchDataParameterKindDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Parameter Kind.
        /// </summary>
        internal static string ParameterTypeMatchDataParameterKindDisplayName {
            get {
                return ResourceManager.GetString("ParameterTypeMatchDataParameterKindDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A Matching Rule that selects target classes and class members based on the type name of a parameter for a member of the target object..
        /// </summary>
        internal static string ParameterTypeMatchingRuleDataDescription {
            get {
                return ResourceManager.GetString("ParameterTypeMatchingRuleDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Parameter Type Matching Rule.
        /// </summary>
        internal static string ParameterTypeMatchingRuleDataDisplayName {
            get {
                return ResourceManager.GetString("ParameterTypeMatchingRuleDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collection of parameter types to match. 
        ///The type name can be a fully qualified type name or just the class name. Each match also specifies whether the match
        ///is case-sensitive, and the parameter kind (which must be one of Input, Output, InputOrOutput, and ReturnValue)..
        /// </summary>
        internal static string ParameterTypeMatchingRuleDataMatchesDescription {
            get {
                return ResourceManager.GetString("ParameterTypeMatchingRuleDataMatchesDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Parameter Types.
        /// </summary>
        internal static string ParameterTypeMatchingRuleDataMatchesDisplayName {
            get {
                return ResourceManager.GetString("ParameterTypeMatchingRuleDataMatchesDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Parameter Type Matching Rule..
        /// </summary>
        internal static string ParameterTypeMatchingRuleDataNameDescription {
            get {
                return ResourceManager.GetString("ParameterTypeMatchingRuleDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string ParameterTypeMatchingRuleDataNameDisplayName {
            get {
                return ResourceManager.GetString("ParameterTypeMatchingRuleDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Parameter Type Matching Rule..
        /// </summary>
        internal static string ParameterTypeMatchingRuleDataTypeNameDescription {
            get {
                return ResourceManager.GetString("ParameterTypeMatchingRuleDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string ParameterTypeMatchingRuleDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("ParameterTypeMatchingRuleDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the category of the target performance counter..
        /// </summary>
        internal static string PerformanceCounterCallHandlerDataCategoryNameDescription {
            get {
                return ResourceManager.GetString("PerformanceCounterCallHandlerDataCategoryNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Category Name.
        /// </summary>
        internal static string PerformanceCounterCallHandlerDataCategoryNameDisplayName {
            get {
                return ResourceManager.GetString("PerformanceCounterCallHandlerDataCategoryNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A Call Handler that increments a specific counter each time it executes in response to invocation of the selected method or setting of the selected property. 
        ///This handler uses the instrumentation features that are part of the Enterprise Library Core. .
        /// </summary>
        internal static string PerformanceCounterCallHandlerDataDescription {
            get {
                return ResourceManager.GetString("PerformanceCounterCallHandlerDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Performance Counter Call Handler.
        /// </summary>
        internal static string PerformanceCounterCallHandlerDataDisplayName {
            get {
                return ResourceManager.GetString("PerformanceCounterCallHandlerDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Whether to increment an &apos;Average duration of each call&apos; counter each time..
        /// </summary>
        internal static string PerformanceCounterCallHandlerDataIncrementAverageCallDurationDescription {
            get {
                return ResourceManager.GetString("PerformanceCounterCallHandlerDataIncrementAverageCallDurationDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Increment Average Call Duration.
        /// </summary>
        internal static string PerformanceCounterCallHandlerDataIncrementAverageCallDurationDisplayName {
            get {
                return ResourceManager.GetString("PerformanceCounterCallHandlerDataIncrementAverageCallDurationDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Whether to increment a &apos;Number of calls per second&apos; counter each time..
        /// </summary>
        internal static string PerformanceCounterCallHandlerDataIncrementCallsPerSecondDescription {
            get {
                return ResourceManager.GetString("PerformanceCounterCallHandlerDataIncrementCallsPerSecondDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Increment Calls Per Second.
        /// </summary>
        internal static string PerformanceCounterCallHandlerDataIncrementCallsPerSecondDisplayName {
            get {
                return ResourceManager.GetString("PerformanceCounterCallHandlerDataIncrementCallsPerSecondDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Whether to increment a &apos;Number of exceptions per second&apos; counter each time..
        /// </summary>
        internal static string PerformanceCounterCallHandlerDataIncrementExceptionsPerSecondDescription {
            get {
                return ResourceManager.GetString("PerformanceCounterCallHandlerDataIncrementExceptionsPerSecondDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Increment Exceptions Per Second.
        /// </summary>
        internal static string PerformanceCounterCallHandlerDataIncrementExceptionsPerSecondDisplayName {
            get {
                return ResourceManager.GetString("PerformanceCounterCallHandlerDataIncrementExceptionsPerSecondDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Whether to increment a &apos;Total number of calls&apos; counter each time..
        /// </summary>
        internal static string PerformanceCounterCallHandlerDataIncrementNumberOfCallsDescription {
            get {
                return ResourceManager.GetString("PerformanceCounterCallHandlerDataIncrementNumberOfCallsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Increment Number Of Calls.
        /// </summary>
        internal static string PerformanceCounterCallHandlerDataIncrementNumberOfCallsDisplayName {
            get {
                return ResourceManager.GetString("PerformanceCounterCallHandlerDataIncrementNumberOfCallsDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Whether to increment a &apos;Total number of exceptions&apos; counter each time..
        /// </summary>
        internal static string PerformanceCounterCallHandlerDataIncrementTotalExceptionsDescription {
            get {
                return ResourceManager.GetString("PerformanceCounterCallHandlerDataIncrementTotalExceptionsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Increment Total Exceptions.
        /// </summary>
        internal static string PerformanceCounterCallHandlerDataIncrementTotalExceptionsDisplayName {
            get {
                return ResourceManager.GetString("PerformanceCounterCallHandlerDataIncrementTotalExceptionsDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the instance of the target performance counter. 
        ///Can include the tokens {method}, {type}, {namespace}, {assembly}, and {appdomain}..
        /// </summary>
        internal static string PerformanceCounterCallHandlerDataInstanceNameDescription {
            get {
                return ResourceManager.GetString("PerformanceCounterCallHandlerDataInstanceNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Instance Name.
        /// </summary>
        internal static string PerformanceCounterCallHandlerDataInstanceNameDisplayName {
            get {
                return ResourceManager.GetString("PerformanceCounterCallHandlerDataInstanceNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Performance Counter Call Handler..
        /// </summary>
        internal static string PerformanceCounterCallHandlerDataNameDescription {
            get {
                return ResourceManager.GetString("PerformanceCounterCallHandlerDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string PerformanceCounterCallHandlerDataNameDisplayName {
            get {
                return ResourceManager.GetString("PerformanceCounterCallHandlerDataNameDisplayName", 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 PerformanceCounterCallHandlerDataOrderDescription {
            get {
                return ResourceManager.GetString("PerformanceCounterCallHandlerDataOrderDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Order.
        /// </summary>
        internal static string PerformanceCounterCallHandlerDataOrderDisplayName {
            get {
                return ResourceManager.GetString("PerformanceCounterCallHandlerDataOrderDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Performance Counter Call Handler..
        /// </summary>
        internal static string PerformanceCounterCallHandlerDataTypeNameDescription {
            get {
                return ResourceManager.GetString("PerformanceCounterCallHandlerDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string PerformanceCounterCallHandlerDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("PerformanceCounterCallHandlerDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Whether to increment a &apos;Total&apos; counter each time..
        /// </summary>
        internal static string PerformanceCounterCallHandlerDataUseTotalCounterDescription {
            get {
                return ResourceManager.GetString("PerformanceCounterCallHandlerDataUseTotalCounterDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use Total Counter.
        /// </summary>
        internal static string PerformanceCounterCallHandlerDataUseTotalCounterDisplayName {
            get {
                return ResourceManager.GetString("PerformanceCounterCallHandlerDataUseTotalCounterDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A set of Matching Rules that select types and their members, and a set of Call Handlers that will execute when calls are made to these types and their members..
        /// </summary>
        internal static string PolicyDataDescription {
            get {
                return ResourceManager.GetString("PolicyDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Policy.
        /// </summary>
        internal static string PolicyDataDisplayName {
            get {
                return ResourceManager.GetString("PolicyDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The set of Call Handlers for this Policy..
        /// </summary>
        internal static string PolicyDataHandlersDescription {
            get {
                return ResourceManager.GetString("PolicyDataHandlersDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Handlers.
        /// </summary>
        internal static string PolicyDataHandlersDisplayName {
            get {
                return ResourceManager.GetString("PolicyDataHandlersDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The set of Matching Rules for this Policy..
        /// </summary>
        internal static string PolicyDataMatchingRulesDescription {
            get {
                return ResourceManager.GetString("PolicyDataMatchingRulesDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Matching Rules.
        /// </summary>
        internal static string PolicyDataMatchingRulesDisplayName {
            get {
                return ResourceManager.GetString("PolicyDataMatchingRulesDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Policy..
        /// </summary>
        internal static string PolicyDataNameDescription {
            get {
                return ResourceManager.GetString("PolicyDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string PolicyDataNameDisplayName {
            get {
                return ResourceManager.GetString("PolicyDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Configuration settings for the Policy Injection Application Block..
        /// </summary>
        internal static string PolicyInjectionSettingsDescription {
            get {
                return ResourceManager.GetString("PolicyInjectionSettingsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Policy Injection Settings.
        /// </summary>
        internal static string PolicyInjectionSettingsDisplayName {
            get {
                return ResourceManager.GetString("PolicyInjectionSettingsDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The set of Policies configured for the Policy Injection Application Block..
        /// </summary>
        internal static string PolicyInjectionSettingsPoliciesDescription {
            get {
                return ResourceManager.GetString("PolicyInjectionSettingsPoliciesDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Policies.
        /// </summary>
        internal static string PolicyInjectionSettingsPoliciesDisplayName {
            get {
                return ResourceManager.GetString("PolicyInjectionSettingsPoliciesDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A class that contains details of a property to match. 
        ///It includes the property name, whether the match is case-sensitive, and a value from the PropertyMatchingOption enumeration that indicates 
        ///if the rule should match on the Get, Set, or both the accessors for a selected parameter. 
        ///Valid values for this are Get, Set, and GetOrSet..
        /// </summary>
        internal static string PropertyMatchDataDescription {
            get {
                return ResourceManager.GetString("PropertyMatchDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Property Match.
        /// </summary>
        internal static string PropertyMatchDataDisplayName {
            get {
                return ResourceManager.GetString("PropertyMatchDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies whether the match should be carried out on a case-sensitive basis. 
        ///The default is false..
        /// </summary>
        internal static string PropertyMatchDataIgnoreCaseDescription {
            get {
                return ResourceManager.GetString("PropertyMatchDataIgnoreCaseDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Ignore Case.
        /// </summary>
        internal static string PropertyMatchDataIgnoreCaseDisplayName {
            get {
                return ResourceManager.GetString("PropertyMatchDataIgnoreCaseDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of a property to match. It can include or consist of the * or ? wildcard characters to select 
        ///multiple properties, and may use square brackets [ ] to specify a range of characters..
        /// </summary>
        internal static string PropertyMatchDataMatchDescription {
            get {
                return ResourceManager.GetString("PropertyMatchDataMatchDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Property Name.
        /// </summary>
        internal static string PropertyMatchDataMatchDisplayName {
            get {
                return ResourceManager.GetString("PropertyMatchDataMatchDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A value from the PropertyMatchingOption enumeration that indicates if the rule should match on the 
        ///Get, Set, or both the accessors for a selected parameter. Valid values are Get, Set, and GetOrSet..
        /// </summary>
        internal static string PropertyMatchDataMatchOptionDescription {
            get {
                return ResourceManager.GetString("PropertyMatchDataMatchOptionDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Match Option.
        /// </summary>
        internal static string PropertyMatchDataMatchOptionDisplayName {
            get {
                return ResourceManager.GetString("PropertyMatchDataMatchOptionDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A Matching Rule that selects target classes and class members based on their name, 
        ///including using wildcard characters, and the combination of accessors they implement..
        /// </summary>
        internal static string PropertyMatchingRuleDataDescription {
            get {
                return ResourceManager.GetString("PropertyMatchingRuleDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Property Matching Rule.
        /// </summary>
        internal static string PropertyMatchingRuleDataDisplayName {
            get {
                return ResourceManager.GetString("PropertyMatchingRuleDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collection of match details containing the property names, case-sensitivity, and accessor details to match..
        /// </summary>
        internal static string PropertyMatchingRuleDataMatchesDescription {
            get {
                return ResourceManager.GetString("PropertyMatchingRuleDataMatchesDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Properties.
        /// </summary>
        internal static string PropertyMatchingRuleDataMatchesDisplayName {
            get {
                return ResourceManager.GetString("PropertyMatchingRuleDataMatchesDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Property Matching Rule..
        /// </summary>
        internal static string PropertyMatchingRuleDataNameDescription {
            get {
                return ResourceManager.GetString("PropertyMatchingRuleDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string PropertyMatchingRuleDataNameDisplayName {
            get {
                return ResourceManager.GetString("PropertyMatchingRuleDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Property Matching Rule..
        /// </summary>
        internal static string PropertyMatchingRuleDataTypeNameDescription {
            get {
                return ResourceManager.GetString("PropertyMatchingRuleDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string PropertyMatchingRuleDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("PropertyMatchingRuleDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A Matching Rule that selects target classes and class members based on the type of the return value..
        /// </summary>
        internal static string ReturnTypeMatchingRuleDataDescription {
            get {
                return ResourceManager.GetString("ReturnTypeMatchingRuleDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Return Type Matching Rule.
        /// </summary>
        internal static string ReturnTypeMatchingRuleDataDisplayName {
            get {
                return ResourceManager.GetString("ReturnTypeMatchingRuleDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies whether the match should be carried out on a case-sensitive basis. The default is false..
        /// </summary>
        internal static string ReturnTypeMatchingRuleDataIgnoreCaseDescription {
            get {
                return ResourceManager.GetString("ReturnTypeMatchingRuleDataIgnoreCaseDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Ignore Case.
        /// </summary>
        internal static string ReturnTypeMatchingRuleDataIgnoreCaseDisplayName {
            get {
                return ResourceManager.GetString("ReturnTypeMatchingRuleDataIgnoreCaseDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the type of the return value of the method to match, or just the type name. .
        /// </summary>
        internal static string ReturnTypeMatchingRuleDataMatchDescription {
            get {
                return ResourceManager.GetString("ReturnTypeMatchingRuleDataMatchDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Return Type.
        /// </summary>
        internal static string ReturnTypeMatchingRuleDataMatchDisplayName {
            get {
                return ResourceManager.GetString("ReturnTypeMatchingRuleDataMatchDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Return Type Matching Rule..
        /// </summary>
        internal static string ReturnTypeMatchingRuleDataNameDescription {
            get {
                return ResourceManager.GetString("ReturnTypeMatchingRuleDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string ReturnTypeMatchingRuleDataNameDisplayName {
            get {
                return ResourceManager.GetString("ReturnTypeMatchingRuleDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Return Type Matching Rule..
        /// </summary>
        internal static string ReturnTypeMatchingRuleDataTypeNameDescription {
            get {
                return ResourceManager.GetString("ReturnTypeMatchingRuleDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string ReturnTypeMatchingRuleDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("ReturnTypeMatchingRuleDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A base class for Matching Rules that selects target classes and class members using string matches..
        /// </summary>
        internal static string StringBasedMatchingRuleDataDescription {
            get {
                return ResourceManager.GetString("StringBasedMatchingRuleDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to String Based Matching Rule.
        /// </summary>
        internal static string StringBasedMatchingRuleDataDisplayName {
            get {
                return ResourceManager.GetString("StringBasedMatchingRuleDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies whether the match should be carried out on a case-sensitive basis. The default is false..
        /// </summary>
        internal static string StringBasedMatchingRuleDataIgnoreCaseDescription {
            get {
                return ResourceManager.GetString("StringBasedMatchingRuleDataIgnoreCaseDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Ignore Case.
        /// </summary>
        internal static string StringBasedMatchingRuleDataIgnoreCaseDisplayName {
            get {
                return ResourceManager.GetString("StringBasedMatchingRuleDataIgnoreCaseDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The string to match..
        /// </summary>
        internal static string StringBasedMatchingRuleDataMatchDescription {
            get {
                return ResourceManager.GetString("StringBasedMatchingRuleDataMatchDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Match.
        /// </summary>
        internal static string StringBasedMatchingRuleDataMatchDisplayName {
            get {
                return ResourceManager.GetString("StringBasedMatchingRuleDataMatchDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the String Based Matching Rule..
        /// </summary>
        internal static string StringBasedMatchingRuleDataNameDescription {
            get {
                return ResourceManager.GetString("StringBasedMatchingRuleDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string StringBasedMatchingRuleDataNameDisplayName {
            get {
                return ResourceManager.GetString("StringBasedMatchingRuleDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the String Based Matching Rule..
        /// </summary>
        internal static string StringBasedMatchingRuleDataTypeNameDescription {
            get {
                return ResourceManager.GetString("StringBasedMatchingRuleDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string StringBasedMatchingRuleDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("StringBasedMatchingRuleDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A Matching Rule that selects target classes and class members based on the name of an attribute of 
        ///type Tag that is applied to a class, or to members (methods or properties) within a class..
        /// </summary>
        internal static string TagAttributeMatchingRuleDataDescription {
            get {
                return ResourceManager.GetString("TagAttributeMatchingRuleDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tag Attribute Matching Rule.
        /// </summary>
        internal static string TagAttributeMatchingRuleDataDisplayName {
            get {
                return ResourceManager.GetString("TagAttributeMatchingRuleDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies whether the match should be carried out on a case-sensitive basis. The default is false..
        /// </summary>
        internal static string TagAttributeMatchingRuleDataIgnoreCaseDescription {
            get {
                return ResourceManager.GetString("TagAttributeMatchingRuleDataIgnoreCaseDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Ignore Case.
        /// </summary>
        internal static string TagAttributeMatchingRuleDataIgnoreCaseDisplayName {
            get {
                return ResourceManager.GetString("TagAttributeMatchingRuleDataIgnoreCaseDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Tag attribute applied to the target object. It cannot include wildcard characters..
        /// </summary>
        internal static string TagAttributeMatchingRuleDataMatchDescription {
            get {
                return ResourceManager.GetString("TagAttributeMatchingRuleDataMatchDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tag Attribute Name.
        /// </summary>
        internal static string TagAttributeMatchingRuleDataMatchDisplayName {
            get {
                return ResourceManager.GetString("TagAttributeMatchingRuleDataMatchDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Tag Attribute Matching Rule..
        /// </summary>
        internal static string TagAttributeMatchingRuleDataNameDescription {
            get {
                return ResourceManager.GetString("TagAttributeMatchingRuleDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string TagAttributeMatchingRuleDataNameDisplayName {
            get {
                return ResourceManager.GetString("TagAttributeMatchingRuleDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Tag Attribute Matching Rule..
        /// </summary>
        internal static string TagAttributeMatchingRuleDataTypeNameDescription {
            get {
                return ResourceManager.GetString("TagAttributeMatchingRuleDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string TagAttributeMatchingRuleDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("TagAttributeMatchingRuleDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A Matching Rule that selects target classes and class members based on the namespace and class name of the target type..
        /// </summary>
        internal static string TypeMatchingRuleDataDescription {
            get {
                return ResourceManager.GetString("TypeMatchingRuleDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type Matching Rule.
        /// </summary>
        internal static string TypeMatchingRuleDataDisplayName {
            get {
                return ResourceManager.GetString("TypeMatchingRuleDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collection of matches for types, including the type name and the case sensitivity. 
        ///The type name may include the full namespace and class name of the target object, or just the class name..
        /// </summary>
        internal static string TypeMatchingRuleDataMatchesDescription {
            get {
                return ResourceManager.GetString("TypeMatchingRuleDataMatchesDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type Matches.
        /// </summary>
        internal static string TypeMatchingRuleDataMatchesDisplayName {
            get {
                return ResourceManager.GetString("TypeMatchingRuleDataMatchesDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Type Matching Rule..
        /// </summary>
        internal static string TypeMatchingRuleDataNameDescription {
            get {
                return ResourceManager.GetString("TypeMatchingRuleDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string TypeMatchingRuleDataNameDisplayName {
            get {
                return ResourceManager.GetString("TypeMatchingRuleDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Type Matching Rule..
        /// </summary>
        internal static string TypeMatchingRuleDataTypeNameDescription {
            get {
                return ResourceManager.GetString("TypeMatchingRuleDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string TypeMatchingRuleDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("TypeMatchingRuleDataTypeNameDisplayName", resourceCulture);
            }
        }
    }
}
