//===============================================================================
// Microsoft patterns & practices Enterprise Library
// Logging 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.Logging.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.Logging.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 Logging Settings.
        /// </summary>
        internal static string AddLoggingSettings {
            get {
                return ResourceManager.GetString("AddLoggingSettings", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A class that writes log messages to a custom logging target, and is added to the Logging Application Block..
        /// </summary>
        internal static string BasicCustomTraceListenerDataDescription {
            get {
                return ResourceManager.GetString("BasicCustomTraceListenerDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Basic Custom Trace Listener.
        /// </summary>
        internal static string BasicCustomTraceListenerDataDisplayName {
            get {
                return ResourceManager.GetString("BasicCustomTraceListenerDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The minimum severity of messages that will be sent to the logging target. 
        ///Valid values are All (the default), Off, Critical, Error, Warning, Information, Verbose, and Activity Tracing. 
        ///The behavior is for messages with the selected severity and all higher severities to be included. 
        ///For example, the Warning setting will allow warning, error, and critical messages to be written to the logging target..
        /// </summary>
        internal static string BasicCustomTraceListenerDataFilterDescription {
            get {
                return ResourceManager.GetString("BasicCustomTraceListenerDataFilterDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Severity Filter.
        /// </summary>
        internal static string BasicCustomTraceListenerDataFilterDisplayName {
            get {
                return ResourceManager.GetString("BasicCustomTraceListenerDataFilterDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Listener..
        /// </summary>
        internal static string BasicCustomTraceListenerDataListenerDataTypeNameDescription {
            get {
                return ResourceManager.GetString("BasicCustomTraceListenerDataListenerDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Listener Data Type.
        /// </summary>
        internal static string BasicCustomTraceListenerDataListenerDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("BasicCustomTraceListenerDataListenerDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Listener..
        /// </summary>
        internal static string BasicCustomTraceListenerDataNameDescription {
            get {
                return ResourceManager.GetString("BasicCustomTraceListenerDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string BasicCustomTraceListenerDataNameDisplayName {
            get {
                return ResourceManager.GetString("BasicCustomTraceListenerDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Listeners that do not output to a Text Formatter use this property to determine which options, or elements, should be included in the trace output. 
        ///Possible values are: CallStack, DateTime, LogicalOperationStack, None, ProcessId, ThreadId, and Timestamp. 
        ///The default is None. This property is optional..
        /// </summary>
        internal static string BasicCustomTraceListenerDataTraceOutputOptionsDescription {
            get {
                return ResourceManager.GetString("BasicCustomTraceListenerDataTraceOutputOptionsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Trace Output Options.
        /// </summary>
        internal static string BasicCustomTraceListenerDataTraceOutputOptionsDisplayName {
            get {
                return ResourceManager.GetString("BasicCustomTraceListenerDataTraceOutputOptionsDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Custom Trace Listener..
        /// </summary>
        internal static string BasicCustomTraceListenerDataTypeNameDescription {
            get {
                return ResourceManager.GetString("BasicCustomTraceListenerDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string BasicCustomTraceListenerDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("BasicCustomTraceListenerDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A Log Message Formatter that generates the output for a log message in a binary format suitable for use with listeners such as the Message Queuing (MSMQ) Trace Listener. .
        /// </summary>
        internal static string BinaryLogFormatterDataDescription {
            get {
                return ResourceManager.GetString("BinaryLogFormatterDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Binary Log Message Formatter.
        /// </summary>
        internal static string BinaryLogFormatterDataDisplayName {
            get {
                return ResourceManager.GetString("BinaryLogFormatterDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Binary Log Message Formatter..
        /// </summary>
        internal static string BinaryLogFormatterDataNameDescription {
            get {
                return ResourceManager.GetString("BinaryLogFormatterDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string BinaryLogFormatterDataNameDisplayName {
            get {
                return ResourceManager.GetString("BinaryLogFormatterDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Binary Log Message Formatter..
        /// </summary>
        internal static string BinaryLogFormatterDataTypeNameDescription {
            get {
                return ResourceManager.GetString("BinaryLogFormatterDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string BinaryLogFormatterDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("BinaryLogFormatterDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies if the filter will allow only messages that match one of the configured categories to pass to the logging target (DenyAllExceptAllowed), 
        ///or will allow all message except those that match one of the configured categories to pass to the logging target (AllowAllExceptDenied)..
        /// </summary>
        internal static string CategoryFilterDataCategoryFilterModeDescription {
            get {
                return ResourceManager.GetString("CategoryFilterDataCategoryFilterModeDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Filter Mode.
        /// </summary>
        internal static string CategoryFilterDataCategoryFilterModeDisplayName {
            get {
                return ResourceManager.GetString("CategoryFilterDataCategoryFilterModeDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The list of all the Categories defined for this Category Filter..
        /// </summary>
        internal static string CategoryFilterDataCategoryFiltersDescription {
            get {
                return ResourceManager.GetString("CategoryFilterDataCategoryFiltersDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Categories.
        /// </summary>
        internal static string CategoryFilterDataCategoryFiltersDisplayName {
            get {
                return ResourceManager.GetString("CategoryFilterDataCategoryFiltersDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A Logging Filter that blocks log messages or allows them to pass to the configured logging target listener(s) based on the categories assigned to the log message. Each Category Filter can be configured for one or more categories, and can be set to allow or block messages assigned to any of these categories..
        /// </summary>
        internal static string CategoryFilterDataDescription {
            get {
                return ResourceManager.GetString("CategoryFilterDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Category Filter.
        /// </summary>
        internal static string CategoryFilterDataDisplayName {
            get {
                return ResourceManager.GetString("CategoryFilterDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Category Filter..
        /// </summary>
        internal static string CategoryFilterDataNameDescription {
            get {
                return ResourceManager.GetString("CategoryFilterDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string CategoryFilterDataNameDisplayName {
            get {
                return ResourceManager.GetString("CategoryFilterDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Category Filter..
        /// </summary>
        internal static string CategoryFilterDataTypeNameDescription {
            get {
                return ResourceManager.GetString("CategoryFilterDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string CategoryFilterDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("CategoryFilterDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A single category in the collection of filters for a Category Filter..
        /// </summary>
        internal static string CategoryFilterEntryDescription {
            get {
                return ResourceManager.GetString("CategoryFilterEntryDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Category.
        /// </summary>
        internal static string CategoryFilterEntryDisplayName {
            get {
                return ResourceManager.GetString("CategoryFilterEntryDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Category Filter Entry..
        /// </summary>
        internal static string CategoryFilterEntryNameDescription {
            get {
                return ResourceManager.GetString("CategoryFilterEntryNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string CategoryFilterEntryNameDisplayName {
            get {
                return ResourceManager.GetString("CategoryFilterEntryNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A class that implements custom formatting for log messages, and is added to the Logging Application Block..
        /// </summary>
        internal static string CustomFormatterDataDescription {
            get {
                return ResourceManager.GetString("CustomFormatterDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Log Message Formatter.
        /// </summary>
        internal static string CustomFormatterDataDisplayName {
            get {
                return ResourceManager.GetString("CustomFormatterDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Custom Log Message Formatter..
        /// </summary>
        internal static string CustomFormatterDataNameDescription {
            get {
                return ResourceManager.GetString("CustomFormatterDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string CustomFormatterDataNameDisplayName {
            get {
                return ResourceManager.GetString("CustomFormatterDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Custom Log Message Formatter..
        /// </summary>
        internal static string CustomFormatterDataTypeNameDescription {
            get {
                return ResourceManager.GetString("CustomFormatterDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string CustomFormatterDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("CustomFormatterDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A class that implements custom filtering for log messages, and is added to the Logging Application Block..
        /// </summary>
        internal static string CustomLogFilterDataDescription {
            get {
                return ResourceManager.GetString("CustomLogFilterDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Logging Filter.
        /// </summary>
        internal static string CustomLogFilterDataDisplayName {
            get {
                return ResourceManager.GetString("CustomLogFilterDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Custom Logging Filter..
        /// </summary>
        internal static string CustomLogFilterDataNameDescription {
            get {
                return ResourceManager.GetString("CustomLogFilterDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string CustomLogFilterDataNameDisplayName {
            get {
                return ResourceManager.GetString("CustomLogFilterDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Custom Logging Filter..
        /// </summary>
        internal static string CustomLogFilterDataTypeNameDescription {
            get {
                return ResourceManager.GetString("CustomLogFilterDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string CustomLogFilterDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("CustomLogFilterDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A class that writes log messages to a custom logging target, and is added to the Logging Application Block..
        /// </summary>
        internal static string CustomTraceListenerDataDescription {
            get {
                return ResourceManager.GetString("CustomTraceListenerDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Trace Listener.
        /// </summary>
        internal static string CustomTraceListenerDataDisplayName {
            get {
                return ResourceManager.GetString("CustomTraceListenerDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The minimum severity of messages that will be sent to the logging target. 
        ///Valid values are All (the default), Off, Critical, Error, Warning, Information, Verbose, and Activity Tracing. 
        ///The behavior is for messages with the selected severity and all higher severities to be included. 
        ///For example, the Warning setting will allow warning, error, and critical messages to be written to the logging target..
        /// </summary>
        internal static string CustomTraceListenerDataFilterDescription {
            get {
                return ResourceManager.GetString("CustomTraceListenerDataFilterDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Severity Filter.
        /// </summary>
        internal static string CustomTraceListenerDataFilterDisplayName {
            get {
                return ResourceManager.GetString("CustomTraceListenerDataFilterDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Formatter.
        /// </summary>
        internal static string CustomTraceListenerDataFormatterDescription {
            get {
                return ResourceManager.GetString("CustomTraceListenerDataFormatterDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Formatter.
        /// </summary>
        internal static string CustomTraceListenerDataFormatterDisplayName {
            get {
                return ResourceManager.GetString("CustomTraceListenerDataFormatterDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Listener..
        /// </summary>
        internal static string CustomTraceListenerDataListenerDataTypeNameDescription {
            get {
                return ResourceManager.GetString("CustomTraceListenerDataListenerDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Listener Data Type.
        /// </summary>
        internal static string CustomTraceListenerDataListenerDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("CustomTraceListenerDataListenerDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Custom Trace Listener..
        /// </summary>
        internal static string CustomTraceListenerDataNameDescription {
            get {
                return ResourceManager.GetString("CustomTraceListenerDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string CustomTraceListenerDataNameDisplayName {
            get {
                return ResourceManager.GetString("CustomTraceListenerDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Listeners that do not output to a Text Formatter use this property to determine which options, or elements, should be included in the trace output. 
        ///Possible values are: CallStack, DateTime, LogicalOperationStack, None, ProcessId, ThreadId, and Timestamp. The default is None. 
        ///This property is optional..
        /// </summary>
        internal static string CustomTraceListenerDataTraceOutputOptionsDescription {
            get {
                return ResourceManager.GetString("CustomTraceListenerDataTraceOutputOptionsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Trace Output Options.
        /// </summary>
        internal static string CustomTraceListenerDataTraceOutputOptionsDisplayName {
            get {
                return ResourceManager.GetString("CustomTraceListenerDataTraceOutputOptionsDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Custom Trace Listener..
        /// </summary>
        internal static string CustomTraceListenerDataTypeNameDescription {
            get {
                return ResourceManager.GetString("CustomTraceListenerDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type Name.
        /// </summary>
        internal static string CustomTraceListenerDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("CustomTraceListenerDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A value from the EmailAuthenticationMode enumeration that specifies how the listener will authenticate the user. 
        ///Valid values are None, WindowsCredentials, and UserNameAndPassword..
        /// </summary>
        internal static string EmailTraceListenerAuthenticationModeDescription {
            get {
                return ResourceManager.GetString("EmailTraceListenerAuthenticationModeDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Authentication  Mode .
        /// </summary>
        internal static string EmailTraceListenerAuthenticationModeDisplayName {
            get {
                return ResourceManager.GetString("EmailTraceListenerAuthenticationModeDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A logging target listener that sends log messages to a specified email server..
        /// </summary>
        internal static string EmailTraceListenerDataDescription {
            get {
                return ResourceManager.GetString("EmailTraceListenerDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Email Trace Listener.
        /// </summary>
        internal static string EmailTraceListenerDataDisplayName {
            get {
                return ResourceManager.GetString("EmailTraceListenerDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The minimum severity of messages that will be sent to the logging target. 
        ///Valid values are All (the default), Off, Critical, Error, Warning, Information, Verbose, and Activity Tracing. 
        ///The behavior is for messages with the selected severity and all higher severities to be included. 
        ///For example, the Warning setting will allow warning, error, and critical messages to be written to the logging target..
        /// </summary>
        internal static string EmailTraceListenerDataFilterDescription {
            get {
                return ResourceManager.GetString("EmailTraceListenerDataFilterDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Severity Filter.
        /// </summary>
        internal static string EmailTraceListenerDataFilterDisplayName {
            get {
                return ResourceManager.GetString("EmailTraceListenerDataFilterDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Log Message Formatter to use for formatting the log message before sending it to the logging target..
        /// </summary>
        internal static string EmailTraceListenerDataFormatterDescription {
            get {
                return ResourceManager.GetString("EmailTraceListenerDataFormatterDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Formatter Name.
        /// </summary>
        internal static string EmailTraceListenerDataFormatterDisplayName {
            get {
                return ResourceManager.GetString("EmailTraceListenerDataFormatterDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;From&apos; address to use for the email message created for each log entry..
        /// </summary>
        internal static string EmailTraceListenerDataFromAddressDescription {
            get {
                return ResourceManager.GetString("EmailTraceListenerDataFromAddressDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to From Address.
        /// </summary>
        internal static string EmailTraceListenerDataFromAddressDisplayName {
            get {
                return ResourceManager.GetString("EmailTraceListenerDataFromAddressDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Email Trace Listener..
        /// </summary>
        internal static string EmailTraceListenerDataListenerDataTypeNameDescription {
            get {
                return ResourceManager.GetString("EmailTraceListenerDataListenerDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Listener Type.
        /// </summary>
        internal static string EmailTraceListenerDataListenerDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("EmailTraceListenerDataListenerDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Email Trace Listener..
        /// </summary>
        internal static string EmailTraceListenerDataNameDescription {
            get {
                return ResourceManager.GetString("EmailTraceListenerDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string EmailTraceListenerDataNameDisplayName {
            get {
                return ResourceManager.GetString("EmailTraceListenerDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The port to use to send the email message to the server that will despatch it. 
        ///The default if not specified is the SMTP port 25..
        /// </summary>
        internal static string EmailTraceListenerDataSmtpPortDescription {
            get {
                return ResourceManager.GetString("EmailTraceListenerDataSmtpPortDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Smtp Port.
        /// </summary>
        internal static string EmailTraceListenerDataSmtpPortDisplayName {
            get {
                return ResourceManager.GetString("EmailTraceListenerDataSmtpPortDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name or IP address of the server that will send the email message. 
        ///The default if not specified is the local host (127.0.0.1)..
        /// </summary>
        internal static string EmailTraceListenerDataSmtpServerDescription {
            get {
                return ResourceManager.GetString("EmailTraceListenerDataSmtpServerDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Smtp Server.
        /// </summary>
        internal static string EmailTraceListenerDataSmtpServerDisplayName {
            get {
                return ResourceManager.GetString("EmailTraceListenerDataSmtpServerDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The suffix to add to the end of the Subject for this email message..
        /// </summary>
        internal static string EmailTraceListenerDataSubjectLineEnderDescription {
            get {
                return ResourceManager.GetString("EmailTraceListenerDataSubjectLineEnderDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Subject Line Suffix.
        /// </summary>
        internal static string EmailTraceListenerDataSubjectLineEnderDisplayName {
            get {
                return ResourceManager.GetString("EmailTraceListenerDataSubjectLineEnderDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The prefix to add at the start of the Subject for this email message..
        /// </summary>
        internal static string EmailTraceListenerDataSubjectLineStarterDescription {
            get {
                return ResourceManager.GetString("EmailTraceListenerDataSubjectLineStarterDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Subject Line Prefix.
        /// </summary>
        internal static string EmailTraceListenerDataSubjectLineStarterDisplayName {
            get {
                return ResourceManager.GetString("EmailTraceListenerDataSubjectLineStarterDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;To&apos; address to use for the email message created for each log entry..
        /// </summary>
        internal static string EmailTraceListenerDataToAddressDescription {
            get {
                return ResourceManager.GetString("EmailTraceListenerDataToAddressDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To Address.
        /// </summary>
        internal static string EmailTraceListenerDataToAddressDisplayName {
            get {
                return ResourceManager.GetString("EmailTraceListenerDataToAddressDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Listeners that do not output to a Text Formatter use this property to determine which options, or elements, should be included in the trace output. 
        ///Possible values are: CallStack, DateTime, LogicalOperationStack, None, ProcessId, ThreadId, and Timestamp. 
        ///The default is None. This property is optional..
        /// </summary>
        internal static string EmailTraceListenerDataTraceOutputOptionsDescription {
            get {
                return ResourceManager.GetString("EmailTraceListenerDataTraceOutputOptionsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Trace Output Options.
        /// </summary>
        internal static string EmailTraceListenerDataTraceOutputOptionsDisplayName {
            get {
                return ResourceManager.GetString("EmailTraceListenerDataTraceOutputOptionsDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Email Trace Listener..
        /// </summary>
        internal static string EmailTraceListenerDataTypeNameDescription {
            get {
                return ResourceManager.GetString("EmailTraceListenerDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string EmailTraceListenerDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("EmailTraceListenerDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The password to use when authenticating the specified user name..
        /// </summary>
        internal static string EmailTraceListenerPasswordDescription {
            get {
                return ResourceManager.GetString("EmailTraceListenerPasswordDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Authentication Password.
        /// </summary>
        internal static string EmailTraceListenerPasswordDisplayName {
            get {
                return ResourceManager.GetString("EmailTraceListenerPasswordDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The user name of the user for authentication when sending email messages to the mail server that will relay them.  .
        /// </summary>
        internal static string EmailTraceListenerUserNameDescription {
            get {
                return ResourceManager.GetString("EmailTraceListenerUserNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Authentication  User Name.
        /// </summary>
        internal static string EmailTraceListenerUserNameDisplayName {
            get {
                return ResourceManager.GetString("EmailTraceListenerUserNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A boolean value that specifies if the listener will authenticate and send messages using Secure Sockets Layer (SSL) encrypted communication..
        /// </summary>
        internal static string EmailTraceListenerUseSSLDescription {
            get {
                return ResourceManager.GetString("EmailTraceListenerUseSSLDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use SSL.
        /// </summary>
        internal static string EmailTraceListenerUseSSLDisplayName {
            get {
                return ResourceManager.GetString("EmailTraceListenerUseSSLDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A logging target listener that writes log messages to a specified text file. Header and footer text can be specified, and the format of the message defined though a template..
        /// </summary>
        internal static string FlatFileTraceListenerDataDescription {
            get {
                return ResourceManager.GetString("FlatFileTraceListenerDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Flat File Trace Listener.
        /// </summary>
        internal static string FlatFileTraceListenerDataDisplayName {
            get {
                return ResourceManager.GetString("FlatFileTraceListenerDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The path and file name for the log file. It can include environment variables such as %WINDIR%, %TEMP%, and %USERPROFILE%..
        /// </summary>
        internal static string FlatFileTraceListenerDataFileNameDescription {
            get {
                return ResourceManager.GetString("FlatFileTraceListenerDataFileNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to File Name.
        /// </summary>
        internal static string FlatFileTraceListenerDataFileNameDisplayName {
            get {
                return ResourceManager.GetString("FlatFileTraceListenerDataFileNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The minimum severity of messages that will be sent to the logging target. 
        ///Valid values are All (the default), Off, Critical, Error, Warning, Information, Verbose, and Activity Tracing. 
        ///The behavior is for messages with the selected severity and all higher severities to be included. 
        ///For example, the Warning setting will allow warning, error, and critical messages to be written to the logging target..
        /// </summary>
        internal static string FlatFileTraceListenerDataFilterDescription {
            get {
                return ResourceManager.GetString("FlatFileTraceListenerDataFilterDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Severity Filter.
        /// </summary>
        internal static string FlatFileTraceListenerDataFilterDisplayName {
            get {
                return ResourceManager.GetString("FlatFileTraceListenerDataFilterDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The text of the footer to add to the log message..
        /// </summary>
        internal static string FlatFileTraceListenerDataFooterDescription {
            get {
                return ResourceManager.GetString("FlatFileTraceListenerDataFooterDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Message Footer.
        /// </summary>
        internal static string FlatFileTraceListenerDataFooterDisplayName {
            get {
                return ResourceManager.GetString("FlatFileTraceListenerDataFooterDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Log Message Formatter to use for formatting the log message before sending it to the logging target..
        /// </summary>
        internal static string FlatFileTraceListenerDataFormatterDescription {
            get {
                return ResourceManager.GetString("FlatFileTraceListenerDataFormatterDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Formatter Name.
        /// </summary>
        internal static string FlatFileTraceListenerDataFormatterDisplayName {
            get {
                return ResourceManager.GetString("FlatFileTraceListenerDataFormatterDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The text of the header to add to the log message..
        /// </summary>
        internal static string FlatFileTraceListenerDataHeaderDescription {
            get {
                return ResourceManager.GetString("FlatFileTraceListenerDataHeaderDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Message Header.
        /// </summary>
        internal static string FlatFileTraceListenerDataHeaderDisplayName {
            get {
                return ResourceManager.GetString("FlatFileTraceListenerDataHeaderDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Listener..
        /// </summary>
        internal static string FlatFileTraceListenerDataListenerDataTypeNameDescription {
            get {
                return ResourceManager.GetString("FlatFileTraceListenerDataListenerDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Listener Data Type.
        /// </summary>
        internal static string FlatFileTraceListenerDataListenerDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("FlatFileTraceListenerDataListenerDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Listener..
        /// </summary>
        internal static string FlatFileTraceListenerDataNameDescription {
            get {
                return ResourceManager.GetString("FlatFileTraceListenerDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string FlatFileTraceListenerDataNameDisplayName {
            get {
                return ResourceManager.GetString("FlatFileTraceListenerDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Listeners that do not output to a Text Formatter use this property to determine which options, or elements, should be included in the trace output. 
        ///Possible values are: CallStack, DateTime, LogicalOperationStack, None, ProcessId, ThreadId, and Timestamp. 
        ///The default is None. This property is optional..
        /// </summary>
        internal static string FlatFileTraceListenerDataTraceOutputOptionsDescription {
            get {
                return ResourceManager.GetString("FlatFileTraceListenerDataTraceOutputOptionsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Trace Output Options.
        /// </summary>
        internal static string FlatFileTraceListenerDataTraceOutputOptionsDisplayName {
            get {
                return ResourceManager.GetString("FlatFileTraceListenerDataTraceOutputOptionsDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Flat File Trace Listener..
        /// </summary>
        internal static string FlatFileTraceListenerDataTypeNameDescription {
            get {
                return ResourceManager.GetString("FlatFileTraceListenerDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string FlatFileTraceListenerDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("FlatFileTraceListenerDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A logging target listener that sends log messages to a specified Windows Event Log such as the Application or System log..
        /// </summary>
        internal static string FormattedEventLogTraceListenerDataDescription {
            get {
                return ResourceManager.GetString("FormattedEventLogTraceListenerDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Event Log Trace Listener.
        /// </summary>
        internal static string FormattedEventLogTraceListenerDataDisplayName {
            get {
                return ResourceManager.GetString("FormattedEventLogTraceListenerDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The minimum severity of messages that will be sent to the logging target. 
        ///Valid values are All (the default), Off, Critical, Error, Warning, Information, Verbose, and Activity Tracing. 
        ///The behavior is for messages with the selected severity and all higher severities to be included. 
        ///For example, the Warning setting will allow warning, error, and critical messages to be written to the logging target..
        /// </summary>
        internal static string FormattedEventLogTraceListenerDataFilterDescription {
            get {
                return ResourceManager.GetString("FormattedEventLogTraceListenerDataFilterDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Severity Filter.
        /// </summary>
        internal static string FormattedEventLogTraceListenerDataFilterDisplayName {
            get {
                return ResourceManager.GetString("FormattedEventLogTraceListenerDataFilterDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Log Message Formatter to use for formatting the log message before sending it to the logging target..
        /// </summary>
        internal static string FormattedEventLogTraceListenerDataFormatterDescription {
            get {
                return ResourceManager.GetString("FormattedEventLogTraceListenerDataFormatterDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Formatter Name.
        /// </summary>
        internal static string FormattedEventLogTraceListenerDataFormatterDisplayName {
            get {
                return ResourceManager.GetString("FormattedEventLogTraceListenerDataFormatterDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Listener..
        /// </summary>
        internal static string FormattedEventLogTraceListenerDataListenerDataTypeNameDescription {
            get {
                return ResourceManager.GetString("FormattedEventLogTraceListenerDataListenerDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Listener Data Type.
        /// </summary>
        internal static string FormattedEventLogTraceListenerDataListenerDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("FormattedEventLogTraceListenerDataListenerDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Windows Event Log to write the log messages to, such as Application or System..
        /// </summary>
        internal static string FormattedEventLogTraceListenerDataLogDescription {
            get {
                return ResourceManager.GetString("FormattedEventLogTraceListenerDataLogDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Log Name.
        /// </summary>
        internal static string FormattedEventLogTraceListenerDataLogDisplayName {
            get {
                return ResourceManager.GetString("FormattedEventLogTraceListenerDataLogDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the machine on which the log messages should be written. The default is the local machine..
        /// </summary>
        internal static string FormattedEventLogTraceListenerDataMachineNameDescription {
            get {
                return ResourceManager.GetString("FormattedEventLogTraceListenerDataMachineNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Machine Name.
        /// </summary>
        internal static string FormattedEventLogTraceListenerDataMachineNameDisplayName {
            get {
                return ResourceManager.GetString("FormattedEventLogTraceListenerDataMachineNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Event Log Listener.
        /// </summary>
        internal static string FormattedEventLogTraceListenerDataNameDescription {
            get {
                return ResourceManager.GetString("FormattedEventLogTraceListenerDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string FormattedEventLogTraceListenerDataNameDisplayName {
            get {
                return ResourceManager.GetString("FormattedEventLogTraceListenerDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The source name to use when writing to the Event Log. The default is &apos;Enterprise Library Logging&apos;..
        /// </summary>
        internal static string FormattedEventLogTraceListenerDataSourceDescription {
            get {
                return ResourceManager.GetString("FormattedEventLogTraceListenerDataSourceDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Source Name.
        /// </summary>
        internal static string FormattedEventLogTraceListenerDataSourceDisplayName {
            get {
                return ResourceManager.GetString("FormattedEventLogTraceListenerDataSourceDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Listeners that do not output to a Text Formatter use this property to determine which options, or elements, should be included in the trace output. 
        ///Possible values are: CallStack, DateTime, LogicalOperationStack, None, ProcessId, ThreadId, and Timestamp. 
        ///The default is None. This property is optional..
        /// </summary>
        internal static string FormattedEventLogTraceListenerDataTraceOutputOptionsDescription {
            get {
                return ResourceManager.GetString("FormattedEventLogTraceListenerDataTraceOutputOptionsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Trace Output Options.
        /// </summary>
        internal static string FormattedEventLogTraceListenerDataTraceOutputOptionsDisplayName {
            get {
                return ResourceManager.GetString("FormattedEventLogTraceListenerDataTraceOutputOptionsDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Event Log Trace Listener..
        /// </summary>
        internal static string FormattedEventLogTraceListenerDataTypeNameDescription {
            get {
                return ResourceManager.GetString("FormattedEventLogTraceListenerDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string FormattedEventLogTraceListenerDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("FormattedEventLogTraceListenerDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Formats the contents of a log message based on the Listener type and logging target. Built-in formatters support text formatting through a template and binary formatting..
        /// </summary>
        internal static string FormatterDataDescription {
            get {
                return ResourceManager.GetString("FormatterDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Formatter.
        /// </summary>
        internal static string FormatterDataDisplayName {
            get {
                return ResourceManager.GetString("FormatterDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Formatter..
        /// </summary>
        internal static string FormatterDataNameDescription {
            get {
                return ResourceManager.GetString("FormatterDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string FormatterDataNameDisplayName {
            get {
                return ResourceManager.GetString("FormatterDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Formatter..
        /// </summary>
        internal static string FormatterDataTypeNameDescription {
            get {
                return ResourceManager.GetString("FormatterDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string FormatterDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("FormatterDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A single Category in the list of Categories for the log message..
        /// </summary>
        internal static string LogCallHandlerCategoryEntryDescription {
            get {
                return ResourceManager.GetString("LogCallHandlerCategoryEntryDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Category Entry.
        /// </summary>
        internal static string LogCallHandlerCategoryEntryDisplayName {
            get {
                return ResourceManager.GetString("LogCallHandlerCategoryEntryDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Category Entry..
        /// </summary>
        internal static string LogCallHandlerCategoryEntryNameDescription {
            get {
                return ResourceManager.GetString("LogCallHandlerCategoryEntryNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string LogCallHandlerCategoryEntryNameDisplayName {
            get {
                return ResourceManager.GetString("LogCallHandlerCategoryEntryNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The message that the Logging Handler will add to the log entry after the target method executes..
        /// </summary>
        internal static string LogCallHandlerDataAfterMessageDescription {
            get {
                return ResourceManager.GetString("LogCallHandlerDataAfterMessageDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to After Message.
        /// </summary>
        internal static string LogCallHandlerDataAfterMessageDisplayName {
            get {
                return ResourceManager.GetString("LogCallHandlerDataAfterMessageDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The message that the Logging Handler will add to the log entry before the target method executes..
        /// </summary>
        internal static string LogCallHandlerDataBeforeMessageDescription {
            get {
                return ResourceManager.GetString("LogCallHandlerDataBeforeMessageDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Before Message.
        /// </summary>
        internal static string LogCallHandlerDataBeforeMessageDisplayName {
            get {
                return ResourceManager.GetString("LogCallHandlerDataBeforeMessageDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The list of categories to which the Logging Handler will write events. 
        ///Each category can be a literal value, and/or include the tokens {method}, {type}, {namespace}, and {assembly}..
        /// </summary>
        internal static string LogCallHandlerDataCategoriesDescription {
            get {
                return ResourceManager.GetString("LogCallHandlerDataCategoriesDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Categories.
        /// </summary>
        internal static string LogCallHandlerDataCategoriesDisplayName {
            get {
                return ResourceManager.GetString("LogCallHandlerDataCategoriesDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A Call Handler that provides the capability to write log messages and trace messages as the client code invokes the selected method or accesses the selected property of the target object. This handler uses the Logging Application Block to create and write log messages..
        /// </summary>
        internal static string LogCallHandlerDataDescription {
            get {
                return ResourceManager.GetString("LogCallHandlerDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Logging Call Handler.
        /// </summary>
        internal static string LogCallHandlerDataDisplayName {
            get {
                return ResourceManager.GetString("LogCallHandlerDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The ID of the event to include in the log message..
        /// </summary>
        internal static string LogCallHandlerDataEventIdDescription {
            get {
                return ResourceManager.GetString("LogCallHandlerDataEventIdDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Event Id.
        /// </summary>
        internal static string LogCallHandlerDataEventIdDisplayName {
            get {
                return ResourceManager.GetString("LogCallHandlerDataEventIdDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Determines whether the call stack will be included in the log message. .
        /// </summary>
        internal static string LogCallHandlerDataIncludeCallStackDescription {
            get {
                return ResourceManager.GetString("LogCallHandlerDataIncludeCallStackDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Include Call Stack.
        /// </summary>
        internal static string LogCallHandlerDataIncludeCallStackDisplayName {
            get {
                return ResourceManager.GetString("LogCallHandlerDataIncludeCallStackDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Determines whether the duration of the call will be included in After Message section of the log message. .
        /// </summary>
        internal static string LogCallHandlerDataIncludeCallTimeDescription {
            get {
                return ResourceManager.GetString("LogCallHandlerDataIncludeCallTimeDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Include Call Time.
        /// </summary>
        internal static string LogCallHandlerDataIncludeCallTimeDisplayName {
            get {
                return ResourceManager.GetString("LogCallHandlerDataIncludeCallTimeDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Determines whether the values of the parameters passed to the target method will be included in the log message. .
        /// </summary>
        internal static string LogCallHandlerDataIncludeParameterValuesDescription {
            get {
                return ResourceManager.GetString("LogCallHandlerDataIncludeParameterValuesDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Include Parameter Values.
        /// </summary>
        internal static string LogCallHandlerDataIncludeParameterValuesDisplayName {
            get {
                return ResourceManager.GetString("LogCallHandlerDataIncludeParameterValuesDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Determines if the handler will write log messages before, after, or both before and after the call to the target object. 
        ///A value from the HandlerLogBehavior enumeration. 
        ///Valid values are Before, After, and BeforeAndAfter..
        /// </summary>
        internal static string LogCallHandlerDataLogBehaviorDescription {
            get {
                return ResourceManager.GetString("LogCallHandlerDataLogBehaviorDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Log Behavior.
        /// </summary>
        internal static string LogCallHandlerDataLogBehaviorDisplayName {
            get {
                return ResourceManager.GetString("LogCallHandlerDataLogBehaviorDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Logging Call Handler..
        /// </summary>
        internal static string LogCallHandlerDataNameDescription {
            get {
                return ResourceManager.GetString("LogCallHandlerDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string LogCallHandlerDataNameDisplayName {
            get {
                return ResourceManager.GetString("LogCallHandlerDataNameDisplayName", 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 LogCallHandlerDataOrderDescription {
            get {
                return ResourceManager.GetString("LogCallHandlerDataOrderDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Order.
        /// </summary>
        internal static string LogCallHandlerDataOrderDisplayName {
            get {
                return ResourceManager.GetString("LogCallHandlerDataOrderDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The priority value of the exception to include in the log message..
        /// </summary>
        internal static string LogCallHandlerDataPriorityDescription {
            get {
                return ResourceManager.GetString("LogCallHandlerDataPriorityDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Priority.
        /// </summary>
        internal static string LogCallHandlerDataPriorityDisplayName {
            get {
                return ResourceManager.GetString("LogCallHandlerDataPriorityDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The severity value of the exception to include in the log message; using values from the TraceEventType enumeration such as Critical, Error, and Warning..
        /// </summary>
        internal static string LogCallHandlerDataSeverityDescription {
            get {
                return ResourceManager.GetString("LogCallHandlerDataSeverityDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Severity.
        /// </summary>
        internal static string LogCallHandlerDataSeverityDisplayName {
            get {
                return ResourceManager.GetString("LogCallHandlerDataSeverityDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Logging Call Handler..
        /// </summary>
        internal static string LogCallHandlerDataTypeNameDescription {
            get {
                return ResourceManager.GetString("LogCallHandlerDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string LogCallHandlerDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("LogCallHandlerDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A filter that allows all logging actions to be turned on and off through one setting..
        /// </summary>
        internal static string LogEnabledFilterDataDescription {
            get {
                return ResourceManager.GetString("LogEnabledFilterDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Logging Enabled Filter.
        /// </summary>
        internal static string LogEnabledFilterDataDisplayName {
            get {
                return ResourceManager.GetString("LogEnabledFilterDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies if all logging is enabled or disabled. Allows all logging actions to be turned on and off through one setting..
        /// </summary>
        internal static string LogEnabledFilterDataEnabledDescription {
            get {
                return ResourceManager.GetString("LogEnabledFilterDataEnabledDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to All Logging Enabled.
        /// </summary>
        internal static string LogEnabledFilterDataEnabledDisplayName {
            get {
                return ResourceManager.GetString("LogEnabledFilterDataEnabledDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Logging Enabled Filter..
        /// </summary>
        internal static string LogEnabledFilterDataNameDescription {
            get {
                return ResourceManager.GetString("LogEnabledFilterDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string LogEnabledFilterDataNameDisplayName {
            get {
                return ResourceManager.GetString("LogEnabledFilterDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Logging Enabled Filter..
        /// </summary>
        internal static string LogEnabledFilterDataTypeNameDescription {
            get {
                return ResourceManager.GetString("LogEnabledFilterDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string LogEnabledFilterDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("LogEnabledFilterDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Log Files (*.log)|*.log|All Files|*.*.
        /// </summary>
        internal static string LogFileDialogFilter {
            get {
                return ResourceManager.GetString("LogFileDialogFilter", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Base class for configuration objects..
        /// </summary>
        internal static string LogFilterDataDescription {
            get {
                return ResourceManager.GetString("LogFilterDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Log Filter.
        /// </summary>
        internal static string LogFilterDataDisplayName {
            get {
                return ResourceManager.GetString("LogFilterDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Log Filter..
        /// </summary>
        internal static string LogFilterDataNameDescription {
            get {
                return ResourceManager.GetString("LogFilterDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string LogFilterDataNameDisplayName {
            get {
                return ResourceManager.GetString("LogFilterDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Logging Filter..
        /// </summary>
        internal static string LogFilterDataTypeNameDescription {
            get {
                return ResourceManager.GetString("LogFilterDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string LogFilterDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("LogFilterDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The default Logging Category to use for messages sent to the block that do not specify a Category. 
        ///Categories allow log messages to be handled and processed in different ways, and sent to different logging targets. 
        ///Log messages can be assigned to one or more categories..
        /// </summary>
        internal static string LoggingSettingsDefaultCategoryDescription {
            get {
                return ResourceManager.GetString("LoggingSettingsDefaultCategoryDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Default Logging Category.
        /// </summary>
        internal static string LoggingSettingsDefaultCategoryDisplayName {
            get {
                return ResourceManager.GetString("LoggingSettingsDefaultCategoryDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Configuration settings for the Logging Application Block..
        /// </summary>
        internal static string LoggingSettingsDescription {
            get {
                return ResourceManager.GetString("LoggingSettingsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Logging Settings.
        /// </summary>
        internal static string LoggingSettingsDisplayName {
            get {
                return ResourceManager.GetString("LoggingSettingsDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Configuration settings for the formatters that can be used with Listeners that generate text or binary output..
        /// </summary>
        internal static string LoggingSettingsFormattersDescription {
            get {
                return ResourceManager.GetString("LoggingSettingsFormattersDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Log Message Formatters.
        /// </summary>
        internal static string LoggingSettingsFormattersDisplayName {
            get {
                return ResourceManager.GetString("LoggingSettingsFormattersDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Filters that block or allow specific or all log messages to be written to the configured logging target based on the Category, Priority, or a custom action. .
        /// </summary>
        internal static string LoggingSettingsLogFiltersDescription {
            get {
                return ResourceManager.GetString("LoggingSettingsLogFiltersDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Logging Filters.
        /// </summary>
        internal static string LoggingSettingsLogFiltersDisplayName {
            get {
                return ResourceManager.GetString("LoggingSettingsLogFiltersDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies whether the block will write a Warning message to the logging target(s) specified in the Logging Errors and Warnings special category 
        ///when a log message is received that does not match any of the defined Logging Categories..
        /// </summary>
        internal static string LoggingSettingsLogWarningWhenNoCategoriesMatchDescription {
            get {
                return ResourceManager.GetString("LoggingSettingsLogWarningWhenNoCategoriesMatchDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Warn If No Category Match.
        /// </summary>
        internal static string LoggingSettingsLogWarningWhenNoCategoriesMatchDisplayName {
            get {
                return ResourceManager.GetString("LoggingSettingsLogWarningWhenNoCategoriesMatchDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Configuration settings for the Logging Application Block..
        /// </summary>
        internal static string LoggingSettingsNameDescription {
            get {
                return ResourceManager.GetString("LoggingSettingsNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string LoggingSettingsNameDisplayName {
            get {
                return ResourceManager.GetString("LoggingSettingsNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, log messages are written using impersonation. This provides some performance advantage for logging. 
        ///This setting allows impersonation to revert to the caller. .
        /// </summary>
        internal static string LoggingSettingsRevertImpersonationDescription {
            get {
                return ResourceManager.GetString("LoggingSettingsRevertImpersonationDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Revert Impersonation.
        /// </summary>
        internal static string LoggingSettingsRevertImpersonationDisplayName {
            get {
                return ResourceManager.GetString("LoggingSettingsRevertImpersonationDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Configuration settings for built-in Categories that handle all events, events that do not match any other Category, and errors that occur when logging..
        /// </summary>
        internal static string LoggingSettingsSpecialTraceSourcesDescription {
            get {
                return ResourceManager.GetString("LoggingSettingsSpecialTraceSourcesDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Special Categories.
        /// </summary>
        internal static string LoggingSettingsSpecialTraceSourcesDisplayName {
            get {
                return ResourceManager.GetString("LoggingSettingsSpecialTraceSourcesDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The Trace Listeners available to direct log messages to specific logging targets such as Windows Event Log or a database..
        /// </summary>
        internal static string LoggingSettingsTraceListenersDescription {
            get {
                return ResourceManager.GetString("LoggingSettingsTraceListenersDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Logging Target Listeners.
        /// </summary>
        internal static string LoggingSettingsTraceListenersDisplayName {
            get {
                return ResourceManager.GetString("LoggingSettingsTraceListenersDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A list of categories to which log messages can be assigned. Log messages can be assigned to one or more Categories. 
        ///Each Category defines how log messages assigned that category will be handled..
        /// </summary>
        internal static string LoggingSettingsTraceSourcesDescription {
            get {
                return ResourceManager.GetString("LoggingSettingsTraceSourcesDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Categories.
        /// </summary>
        internal static string LoggingSettingsTraceSourcesDisplayName {
            get {
                return ResourceManager.GetString("LoggingSettingsTraceSourcesDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies whether activity tracing is enabled. When enabled, code can use Tracer instances to trace individual activities and associate the resulting log messages through an Activity ID..
        /// </summary>
        internal static string LoggingSettingsTracingEnabledDescription {
            get {
                return ResourceManager.GetString("LoggingSettingsTracingEnabledDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Activity Tracing Enabled.
        /// </summary>
        internal static string LoggingSettingsTracingEnabledDisplayName {
            get {
                return ResourceManager.GetString("LoggingSettingsTracingEnabledDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Queue Path.
        /// </summary>
        internal static string MsmqTraceListenerDataCategoryQueuePathDescription {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataCategoryQueuePathDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Queue Path.
        /// </summary>
        internal static string MsmqTraceListenerDataCategoryQueuePathDisplayName {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataCategoryQueuePathDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A logging target listener that writes log messages to a specified Windows Message Queuing queue. 
        ///A wide range of options can be specified for the queues, priority, transaction, and encryption..
        /// </summary>
        internal static string MsmqTraceListenerDataDescription {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Message Queuing Trace Listener.
        /// </summary>
        internal static string MsmqTraceListenerDataDisplayName {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The minimum severity of messages that will be sent to the logging target. 
        ///Valid values are All (the default), Off, Critical, Error, Warning, Information, Verbose, and Activity Tracing. 
        ///The behavior is for messages with the selected severity and all higher severities to be included. 
        ///For example, the Warning setting will allow warning, error, and critical messages to be written to the logging target..
        /// </summary>
        internal static string MsmqTraceListenerDataFilterDescription {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataFilterDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Severity Filter.
        /// </summary>
        internal static string MsmqTraceListenerDataFilterDisplayName {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataFilterDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The formatter to use with this trace listener. 
        ///This must be the Binary Formatter when you use this listener with the Message Queuing distributor service..
        /// </summary>
        internal static string MsmqTraceListenerDataFormatterDescription {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataFormatterDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Formatter Name.
        /// </summary>
        internal static string MsmqTraceListenerDataFormatterDisplayName {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataFormatterDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Listener..
        /// </summary>
        internal static string MsmqTraceListenerDataListenerDataTypeNameDescription {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataListenerDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Listener Data Type.
        /// </summary>
        internal static string MsmqTraceListenerDataListenerDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataListenerDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sets the priority of a log entry. 
        ///This determines its priority while the log entry is in transit and when it is inserted into its destination queue. 
        ///Possible values are: AboveNormal, High, Highest, Low, Lowest, Normal, VeryHigh, and VeryLow..
        /// </summary>
        internal static string MsmqTraceListenerDataMessagePriorityDescription {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataMessagePriorityDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Message Priority.
        /// </summary>
        internal static string MsmqTraceListenerDataMessagePriorityDisplayName {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataMessagePriorityDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Message Queuing (MSMQ) Trace Listener..
        /// </summary>
        internal static string MsmqTraceListenerDataNameDescription {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string MsmqTraceListenerDataNameDisplayName {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The path to the queue that the Msmq TraceListener instance uses. This attribute is a message queuing path, and it applies to the MsmqTraceListener class..
        /// </summary>
        internal static string MsmqTraceListenerDataQueuePathDescription {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataQueuePathDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Queue Path.
        /// </summary>
        internal static string MsmqTraceListenerDataQueuePathDisplayName {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataQueuePathDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies whether the log entry is guaranteed to be delivered if there is a computer failure or network problem..
        /// </summary>
        internal static string MsmqTraceListenerDataRecoverableDescription {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataRecoverableDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Recoverable.
        /// </summary>
        internal static string MsmqTraceListenerDataRecoverableDisplayName {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataRecoverableDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The total time for a log entry to be received by the destination queue..
        /// </summary>
        internal static string MsmqTraceListenerDataTimeToBeReceivedDescription {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataTimeToBeReceivedDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Time To Be Received.
        /// </summary>
        internal static string MsmqTraceListenerDataTimeToBeReceivedDisplayName {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataTimeToBeReceivedDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The maximum time for the log entry to reach the queue..
        /// </summary>
        internal static string MsmqTraceListenerDataTimeToReachQueueDescription {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataTimeToReachQueueDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Time To Reach Queue.
        /// </summary>
        internal static string MsmqTraceListenerDataTimeToReachQueueDisplayName {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataTimeToReachQueueDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Listeners that do not output to a Text Formatter use this property to determine which options, or elements, should be included in the trace output. 
        ///Possible values are: CallStack, DateTime, LogicalOperationStack, None, ProcessId, ThreadId, and Timestamp. 
        ///The default is None. This property is optional..
        /// </summary>
        internal static string MsmqTraceListenerDataTraceOutputOptionsDescription {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataTraceOutputOptionsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Trace Output Options.
        /// </summary>
        internal static string MsmqTraceListenerDataTraceOutputOptionsDisplayName {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataTraceOutputOptionsDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type of a Message Queuing transaction. Possible values are Automatic, None, and Single..
        /// </summary>
        internal static string MsmqTraceListenerDataTransactionTypeDescription {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataTransactionTypeDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Transaction Type.
        /// </summary>
        internal static string MsmqTraceListenerDataTransactionTypeDisplayName {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataTransactionTypeDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Message Queuing (MSMQ) Trace Listener..
        /// </summary>
        internal static string MsmqTraceListenerDataTypeNameDescription {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string MsmqTraceListenerDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies whether the message was (or must be) authenticated before being sent..
        /// </summary>
        internal static string MsmqTraceListenerDataUseAuthenticationDescription {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataUseAuthenticationDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use Authentication.
        /// </summary>
        internal static string MsmqTraceListenerDataUseAuthenticationDisplayName {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataUseAuthenticationDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies whether a copy of a message that could not be delivered should be sent to a dead-letter queue..
        /// </summary>
        internal static string MsmqTraceListenerDataUseDeadLetterQueueDescription {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataUseDeadLetterQueueDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use Dead Letter Queue.
        /// </summary>
        internal static string MsmqTraceListenerDataUseDeadLetterQueueDisplayName {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataUseDeadLetterQueueDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies whether to make the message private..
        /// </summary>
        internal static string MsmqTraceListenerDataUseEncryptionDescription {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataUseEncryptionDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use Encryption.
        /// </summary>
        internal static string MsmqTraceListenerDataUseEncryptionDisplayName {
            get {
                return ResourceManager.GetString("MsmqTraceListenerDataUseEncryptionDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A filter that blocks log messages or allows them to pass based on the priority specified in the log message. .
        /// </summary>
        internal static string PriorityFilterDataDescription {
            get {
                return ResourceManager.GetString("PriorityFilterDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Priority Filter.
        /// </summary>
        internal static string PriorityFilterDataDisplayName {
            get {
                return ResourceManager.GetString("PriorityFilterDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The maximum priority value for messages to be passed to the logging target listener(s).  
        ///Messages with a priority above this value are not sent to the logging target. .
        /// </summary>
        internal static string PriorityFilterDataMaximumPriorityDescription {
            get {
                return ResourceManager.GetString("PriorityFilterDataMaximumPriorityDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Maximum Priority.
        /// </summary>
        internal static string PriorityFilterDataMaximumPriorityDisplayName {
            get {
                return ResourceManager.GetString("PriorityFilterDataMaximumPriorityDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The minimum priority value for messages to be passed to the logging target listener(s).  
        ///Messages with a priority below this value are not sent to the logging target..
        /// </summary>
        internal static string PriorityFilterDataMinimumPriorityDescription {
            get {
                return ResourceManager.GetString("PriorityFilterDataMinimumPriorityDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Minimum Priority.
        /// </summary>
        internal static string PriorityFilterDataMinimumPriorityDisplayName {
            get {
                return ResourceManager.GetString("PriorityFilterDataMinimumPriorityDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Priority Filter..
        /// </summary>
        internal static string PriorityFilterDataNameDescription {
            get {
                return ResourceManager.GetString("PriorityFilterDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string PriorityFilterDataNameDisplayName {
            get {
                return ResourceManager.GetString("PriorityFilterDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Priority Logging Filter..
        /// </summary>
        internal static string PriorityFilterDataTypeNameDescription {
            get {
                return ResourceManager.GetString("PriorityFilterDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string PriorityFilterDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("PriorityFilterDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A logging target listener that writes log messages to a series of text files. 
        ///The listener can start a new file at specified intervals, use a specified file naming pattern, and optionally overwrite existing files. 
        ///Header and footer text can be specified, and the format of the message defined though a template..
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataDescription {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Rolling Flat File Trace Listener.
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataDisplayName {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The path and name of the disk file to write log message to. It can include environment variables such as %WINDIR%, %TEMP%, and %USERPROFILE%..
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataFileNameDescription {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataFileNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to File Name.
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataFileNameDisplayName {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataFileNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The minimum severity of messages that will be sent to the logging target. 
        ///Valid values are All (the default), Off, Critical, Error, Warning, Information, Verbose, and Activity Tracing. 
        ///The behavior is for messages with the selected severity and all higher severities to be included. 
        ///For example, the Warning setting will allow warning, error, and critical messages to be written to the logging target..
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataFilterDescription {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataFilterDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Severity Filter.
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataFilterDisplayName {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataFilterDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The text of the footer to add to the log message..
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataFooterDescription {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataFooterDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Message Footer.
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataFooterDisplayName {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataFooterDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Log Message Formatter to use for formatting the log message before sending it to the logging target..
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataFormatterDescription {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataFormatterDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Formatter Name.
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataFormatterDisplayName {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataFormatterDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The text of the header to add to the log message..
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataHeaderDescription {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataHeaderDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Message Header.
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataHeaderDisplayName {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataHeaderDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Listener..
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataListenerDataTypeNameDescription {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataListenerDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Listener Data Type.
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataListenerDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataListenerDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The maximum number of log files to retain. When set to a numeric value, the listener will purge old files based on the file creation date when the number exceeds the specified value..
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataMaxArchivedFilesDescription {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataMaxArchivedFilesDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Max Archived Files.
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataMaxArchivedFilesDisplayName {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataMaxArchivedFilesDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Rolling Flat File Trace Listener..
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataNameDescription {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataNameDisplayName {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Determines what occurs to an existing file when it rolls over. 
        ///Increment means that the listener will create a new file using a name created by incrementing the timestamp. 
        ///Overwrite means that, if a value for the Timestamp Pattern is not specified, the existing file is overwritten..
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataRollFileExistsBehaviorDescription {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataRollFileExistsBehaviorDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to File Exists Behavior.
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataRollFileExistsBehaviorDisplayName {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataRollFileExistsBehaviorDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Determines when the log file rolls over. The default is None. 
        ///Other options are intervals of Midnight, Minute, Hour, Day, Month, or Year. 
        ///If required, both a maximum file size and a roll interval can be specified..
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataRollIntervalDescription {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataRollIntervalDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Roll Interval.
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataRollIntervalDisplayName {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataRollIntervalDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The maximum size of the log file, in kilobytes, before it rolls over. If required, both a maximum file size and a roll interval can be specified..
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataRollSizeKBDescription {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataRollSizeKBDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Roll Size KB.
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataRollSizeKBDisplayName {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataRollSizeKBDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The date/time format used to create the suffix for the file name, such as &apos;yyyy-MM-dd&apos;..
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataTimeStampPatternDescription {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataTimeStampPatternDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Timestamp Pattern.
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataTimeStampPatternDisplayName {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataTimeStampPatternDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Listeners that do not output to a Text Formatter use this property to determine which options, or elements, should be included in the trace output. 
        ///Possible values are: CallStack, DateTime, LogicalOperationStack, None, ProcessId, ThreadId, and Timestamp. 
        ///The default is None. This property is optional..
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataTraceOutputOptionsDescription {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataTraceOutputOptionsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Trace Output Options.
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataTraceOutputOptionsDisplayName {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataTraceOutputOptionsDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Rolling Flat File Trace Listener..
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataTypeNameDescription {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string RollingFlatFileTraceListenerDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("RollingFlatFileTraceListenerDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A filter that can be used to specify a logging target for all log messages sent to the Logging Application Block..
        /// </summary>
        internal static string SpecialTraceSourcesDataAllEventsTraceSourceDescription {
            get {
                return ResourceManager.GetString("SpecialTraceSourcesDataAllEventsTraceSourceDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to All Events Category Filter.
        /// </summary>
        internal static string SpecialTraceSourcesDataAllEventsTraceSourceDisplayName {
            get {
                return ResourceManager.GetString("SpecialTraceSourcesDataAllEventsTraceSourceDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Filters that allow all events, unprocessed events, and logging and working messages to be sent to specified logging target listeners..
        /// </summary>
        internal static string SpecialTraceSourcesDataDescription {
            get {
                return ResourceManager.GetString("SpecialTraceSourcesDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Special Category Filters.
        /// </summary>
        internal static string SpecialTraceSourcesDataDisplayName {
            get {
                return ResourceManager.GetString("SpecialTraceSourcesDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A filter that can be used to specify a logging target for log messages when a logging error occurs..
        /// </summary>
        internal static string SpecialTraceSourcesDataErrorsTraceSourceDescription {
            get {
                return ResourceManager.GetString("SpecialTraceSourcesDataErrorsTraceSourceDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Errors Category Filter.
        /// </summary>
        internal static string SpecialTraceSourcesDataErrorsTraceSourceDisplayName {
            get {
                return ResourceManager.GetString("SpecialTraceSourcesDataErrorsTraceSourceDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A filter that can be used to specify a logging target for log messages that do not match any configured category..
        /// </summary>
        internal static string SpecialTraceSourcesDataNotProcessedTraceSourceDescription {
            get {
                return ResourceManager.GetString("SpecialTraceSourcesDataNotProcessedTraceSourceDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unprocessed Category Filter.
        /// </summary>
        internal static string SpecialTraceSourcesDataNotProcessedTraceSourceDisplayName {
            get {
                return ResourceManager.GetString("SpecialTraceSourcesDataNotProcessedTraceSourceDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An abstract base class for trace listeners that monitor trace and debug output..
        /// </summary>
        internal static string SystemDiagnosticsTraceListenerDataDescription {
            get {
                return ResourceManager.GetString("SystemDiagnosticsTraceListenerDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to System Diagnostics Trace Listener.
        /// </summary>
        internal static string SystemDiagnosticsTraceListenerDataDisplayName {
            get {
                return ResourceManager.GetString("SystemDiagnosticsTraceListenerDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The minimum severity of messages that will be sent to the logging target. 
        ///Valid values are All (the default), Off, Critical, Error, Warning, Information, Verbose, and Activity Tracing. 
        ///The behavior is for messages with the selected severity and all higher severities to be included. 
        ///For example, the Warning setting will allow warning, error, and critical messages to be written to the logging target..
        /// </summary>
        internal static string SystemDiagnosticsTraceListenerDataFilterDescription {
            get {
                return ResourceManager.GetString("SystemDiagnosticsTraceListenerDataFilterDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Severity Filter.
        /// </summary>
        internal static string SystemDiagnosticsTraceListenerDataFilterDisplayName {
            get {
                return ResourceManager.GetString("SystemDiagnosticsTraceListenerDataFilterDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Listener..
        /// </summary>
        internal static string SystemDiagnosticsTraceListenerDataListenerDataTypeNameDescription {
            get {
                return ResourceManager.GetString("SystemDiagnosticsTraceListenerDataListenerDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Listener Data Type.
        /// </summary>
        internal static string SystemDiagnosticsTraceListenerDataListenerDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("SystemDiagnosticsTraceListenerDataListenerDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the System Diagnostics Trace Listener..
        /// </summary>
        internal static string SystemDiagnosticsTraceListenerDataNameDescription {
            get {
                return ResourceManager.GetString("SystemDiagnosticsTraceListenerDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string SystemDiagnosticsTraceListenerDataNameDisplayName {
            get {
                return ResourceManager.GetString("SystemDiagnosticsTraceListenerDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Listeners that do not output to a Text Formatter use this property to determine which options, or elements, should be included in the trace output. 
        ///Possible values are: CallStack, DateTime, LogicalOperationStack, None, ProcessId, ThreadId, and Timestamp. 
        ///The default is None. This property is optional..
        /// </summary>
        internal static string SystemDiagnosticsTraceListenerDataTraceOutputOptionsDescription {
            get {
                return ResourceManager.GetString("SystemDiagnosticsTraceListenerDataTraceOutputOptionsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Trace Output Options.
        /// </summary>
        internal static string SystemDiagnosticsTraceListenerDataTraceOutputOptionsDisplayName {
            get {
                return ResourceManager.GetString("SystemDiagnosticsTraceListenerDataTraceOutputOptionsDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the System Diagnostics Trace Listener..
        /// </summary>
        internal static string SystemDiagnosticsTraceListenerDataTypeNameDescription {
            get {
                return ResourceManager.GetString("SystemDiagnosticsTraceListenerDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string SystemDiagnosticsTraceListenerDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("SystemDiagnosticsTraceListenerDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A Log Message Formatter that generates the output for a log message in a text format suitable for use with listeners such as the 
        ///Flat File, Rolling Flat File, Email, and Event Log Trace Listeners. .
        /// </summary>
        internal static string TextFormatterDataDescription {
            get {
                return ResourceManager.GetString("TextFormatterDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Text Formatter.
        /// </summary>
        internal static string TextFormatterDataDisplayName {
            get {
                return ResourceManager.GetString("TextFormatterDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Text Log Message Formatter..
        /// </summary>
        internal static string TextFormatterDataNameDescription {
            get {
                return ResourceManager.GetString("TextFormatterDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string TextFormatterDataNameDisplayName {
            get {
                return ResourceManager.GetString("TextFormatterDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The template used to format the log message. It contains tokens that are replaced by values from the log message. 
        ///Use the editor to edit the default template and insert tokens and text..
        /// </summary>
        internal static string TextFormatterDataTemplateDescription {
            get {
                return ResourceManager.GetString("TextFormatterDataTemplateDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Template.
        /// </summary>
        internal static string TextFormatterDataTemplateDisplayName {
            get {
                return ResourceManager.GetString("TextFormatterDataTemplateDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Text Log Message Formatter..
        /// </summary>
        internal static string TextFormatterDataTypeNameDescription {
            get {
                return ResourceManager.GetString("TextFormatterDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string TextFormatterDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("TextFormatterDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A collection of Trace Listeners..
        /// </summary>
        internal static string TraceListenerDataCollectionDescription {
            get {
                return ResourceManager.GetString("TraceListenerDataCollectionDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Trace Listener Data Collection.
        /// </summary>
        internal static string TraceListenerDataCollectionDisplayName {
            get {
                return ResourceManager.GetString("TraceListenerDataCollectionDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An abstract base class for all trace listeners..
        /// </summary>
        internal static string TraceListenerDataDescription {
            get {
                return ResourceManager.GetString("TraceListenerDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Trace Listener.
        /// </summary>
        internal static string TraceListenerDataDisplayName {
            get {
                return ResourceManager.GetString("TraceListenerDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The minimum severity of messages that will be sent to the logging target. 
        ///Valid values are All (the default), Off, Critical, Error, Warning, Information, Verbose, and Activity Tracing. 
        ///The behavior is for messages with the selected severity and all higher severities to be included. 
        ///For example, the Warning setting will allow warning, error, and critical messages to be written to the logging target..
        /// </summary>
        internal static string TraceListenerDataFilterDescription {
            get {
                return ResourceManager.GetString("TraceListenerDataFilterDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Severity Filter.
        /// </summary>
        internal static string TraceListenerDataFilterDisplayName {
            get {
                return ResourceManager.GetString("TraceListenerDataFilterDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Listener..
        /// </summary>
        internal static string TraceListenerDataListenerDataTypeNameDescription {
            get {
                return ResourceManager.GetString("TraceListenerDataListenerDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Listener Data Type.
        /// </summary>
        internal static string TraceListenerDataListenerDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("TraceListenerDataListenerDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Trace Listener..
        /// </summary>
        internal static string TraceListenerDataNameDescription {
            get {
                return ResourceManager.GetString("TraceListenerDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string TraceListenerDataNameDisplayName {
            get {
                return ResourceManager.GetString("TraceListenerDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Listeners that do not output to a Text Formatter use this property to determine which options, or elements, should be included in the trace output. 
        ///Possible values are: CallStack, DateTime, LogicalOperationStack, None, ProcessId, ThreadId, and Timestamp. 
        ///The default is None. This property is optional..
        /// </summary>
        internal static string TraceListenerDataTraceOutputOptionsDescription {
            get {
                return ResourceManager.GetString("TraceListenerDataTraceOutputOptionsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Trace Output Options.
        /// </summary>
        internal static string TraceListenerDataTraceOutputOptionsDisplayName {
            get {
                return ResourceManager.GetString("TraceListenerDataTraceOutputOptionsDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Trace Listener..
        /// </summary>
        internal static string TraceListenerDataTypeNameDescription {
            get {
                return ResourceManager.GetString("TraceListenerDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string TraceListenerDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("TraceListenerDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The Logging Target Listener to which log entries will be sent..
        /// </summary>
        internal static string TraceListenerReferenceDataDescription {
            get {
                return ResourceManager.GetString("TraceListenerReferenceDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Trace Listener.
        /// </summary>
        internal static string TraceListenerReferenceDataDisplayName {
            get {
                return ResourceManager.GetString("TraceListenerReferenceDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the Logging Target Listener to which log entries will be sent..
        /// </summary>
        internal static string TraceListenerReferenceDataNameDescription {
            get {
                return ResourceManager.GetString("TraceListenerReferenceDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Trace Listener Name.
        /// </summary>
        internal static string TraceListenerReferenceDataNameDisplayName {
            get {
                return ResourceManager.GetString("TraceListenerReferenceDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies if the Logging Target Listeners will automatically flush messages to the target as soon as they are received. 
        ///When set to False, the Listener buffers the messages and sends them to the target in batches or when significant events occur such as the machine shutting down..
        /// </summary>
        internal static string TraceSourceDataAutoFlushDescription {
            get {
                return ResourceManager.GetString("TraceSourceDataAutoFlushDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Auto Flush.
        /// </summary>
        internal static string TraceSourceDataAutoFlushDisplayName {
            get {
                return ResourceManager.GetString("TraceSourceDataAutoFlushDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The severity level for messages that will be logged. Messages sent to the block for this category, 
        ///and with a lower severity than that specified, will not be logged for this category..
        /// </summary>
        internal static string TraceSourceDataDefaultLevelDescription {
            get {
                return ResourceManager.GetString("TraceSourceDataDefaultLevelDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Minimum Severity.
        /// </summary>
        internal static string TraceSourceDataDefaultLevelDisplayName {
            get {
                return ResourceManager.GetString("TraceSourceDataDefaultLevelDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Defines the settings for a Category to which log messages can be assigned. 
        ///Log messages can be assigned to one or more Categories. 
        ///Each Category defines how log messages assigned that category will be handled..
        /// </summary>
        internal static string TraceSourceDataDescription {
            get {
                return ResourceManager.GetString("TraceSourceDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Category.
        /// </summary>
        internal static string TraceSourceDataDisplayName {
            get {
                return ResourceManager.GetString("TraceSourceDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the logging category..
        /// </summary>
        internal static string TraceSourceDataNameDescription {
            get {
                return ResourceManager.GetString("TraceSourceDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string TraceSourceDataNameDisplayName {
            get {
                return ResourceManager.GetString("TraceSourceDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The list of Logging Target Listeners for this Category or Special Filter..
        /// </summary>
        internal static string TraceSourceDataTraceListenersDescription {
            get {
                return ResourceManager.GetString("TraceSourceDataTraceListenersDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Listeners.
        /// </summary>
        internal static string TraceSourceDataTraceListenersDisplayName {
            get {
                return ResourceManager.GetString("TraceSourceDataTraceListenersDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A logging target listener that raises a WMI event for each log message..
        /// </summary>
        internal static string WmiTraceListenerDataDescription {
            get {
                return ResourceManager.GetString("WmiTraceListenerDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to WMI Trace Listener.
        /// </summary>
        internal static string WmiTraceListenerDataDisplayName {
            get {
                return ResourceManager.GetString("WmiTraceListenerDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The minimum severity of messages that will be sent to the logging target. 
        ///Valid values are All (the default), Off, Critical, Error, Warning, Information, Verbose, and Activity Tracing. 
        ///The behavior is for messages with the selected severity and all higher severities to be included. 
        ///For example, the Warning setting will allow warning, error, and critical messages to be written to the logging target..
        /// </summary>
        internal static string WmiTraceListenerDataFilterDescription {
            get {
                return ResourceManager.GetString("WmiTraceListenerDataFilterDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Severity Filter.
        /// </summary>
        internal static string WmiTraceListenerDataFilterDisplayName {
            get {
                return ResourceManager.GetString("WmiTraceListenerDataFilterDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Listener..
        /// </summary>
        internal static string WmiTraceListenerDataListenerDataTypeNameDescription {
            get {
                return ResourceManager.GetString("WmiTraceListenerDataListenerDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Listener Data Type.
        /// </summary>
        internal static string WmiTraceListenerDataListenerDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("WmiTraceListenerDataListenerDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the WMI Trace Listener..
        /// </summary>
        internal static string WmiTraceListenerDataNameDescription {
            get {
                return ResourceManager.GetString("WmiTraceListenerDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string WmiTraceListenerDataNameDisplayName {
            get {
                return ResourceManager.GetString("WmiTraceListenerDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Listeners that do not output to a Text Formatter use this property to determine which options, or elements, should be included in the trace output. 
        ///Possible values are: CallStack, DateTime, LogicalOperationStack, None, ProcessId, ThreadId, and Timestamp. 
        ///The default is None. This property is optional..
        /// </summary>
        internal static string WmiTraceListenerDataTraceOutputOptionsDescription {
            get {
                return ResourceManager.GetString("WmiTraceListenerDataTraceOutputOptionsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Trace Output Options.
        /// </summary>
        internal static string WmiTraceListenerDataTraceOutputOptionsDisplayName {
            get {
                return ResourceManager.GetString("WmiTraceListenerDataTraceOutputOptionsDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the WMI Trace Listener..
        /// </summary>
        internal static string WmiTraceListenerDataTypeNameDescription {
            get {
                return ResourceManager.GetString("WmiTraceListenerDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string WmiTraceListenerDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("WmiTraceListenerDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A logging target listener that writes log messages in XML format to a specified text file..
        /// </summary>
        internal static string XmlTraceListenerDataDescription {
            get {
                return ResourceManager.GetString("XmlTraceListenerDataDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to XML Trace Listener.
        /// </summary>
        internal static string XmlTraceListenerDataDisplayName {
            get {
                return ResourceManager.GetString("XmlTraceListenerDataDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The path and name of the disk file to write the log messages to. It can include environment variables such as %WINDIR%, %TEMP%, and %USERPROFILE%..
        /// </summary>
        internal static string XmlTraceListenerDataFileNameDescription {
            get {
                return ResourceManager.GetString("XmlTraceListenerDataFileNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to File Name.
        /// </summary>
        internal static string XmlTraceListenerDataFileNameDisplayName {
            get {
                return ResourceManager.GetString("XmlTraceListenerDataFileNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The minimum severity of messages that will be sent to the logging target. 
        ///Valid values are All (the default), Off, Critical, Error, Warning, Information, Verbose, and Activity Tracing. 
        ///The behavior is for messages with the selected severity and all higher severities to be included. 
        ///For example, the Warning setting will allow warning, error, and critical messages to be written to the logging target..
        /// </summary>
        internal static string XmlTraceListenerDataFilterDescription {
            get {
                return ResourceManager.GetString("XmlTraceListenerDataFilterDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Severity Filter.
        /// </summary>
        internal static string XmlTraceListenerDataFilterDisplayName {
            get {
                return ResourceManager.GetString("XmlTraceListenerDataFilterDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the Listener..
        /// </summary>
        internal static string XmlTraceListenerDataListenerDataTypeNameDescription {
            get {
                return ResourceManager.GetString("XmlTraceListenerDataListenerDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Listener Data Type.
        /// </summary>
        internal static string XmlTraceListenerDataListenerDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("XmlTraceListenerDataListenerDataTypeNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the XML Trace Listener..
        /// </summary>
        internal static string XmlTraceListenerDataNameDescription {
            get {
                return ResourceManager.GetString("XmlTraceListenerDataNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string XmlTraceListenerDataNameDisplayName {
            get {
                return ResourceManager.GetString("XmlTraceListenerDataNameDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Listeners that do not output to a Text Formatter use this property to determine which options, or elements, should be included in the trace output. 
        ///Possible values are: CallStack, DateTime, LogicalOperationStack, None, ProcessId, ThreadId, and Timestamp. 
        ///The default is None. This property is optional..
        /// </summary>
        internal static string XmlTraceListenerDataTraceOutputOptionsDescription {
            get {
                return ResourceManager.GetString("XmlTraceListenerDataTraceOutputOptionsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Trace Output Options.
        /// </summary>
        internal static string XmlTraceListenerDataTraceOutputOptionsDisplayName {
            get {
                return ResourceManager.GetString("XmlTraceListenerDataTraceOutputOptionsDisplayName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fully qualified type name of the XML Trace Listener..
        /// </summary>
        internal static string XmlTraceListenerDataTypeNameDescription {
            get {
                return ResourceManager.GetString("XmlTraceListenerDataTypeNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type.
        /// </summary>
        internal static string XmlTraceListenerDataTypeNameDisplayName {
            get {
                return ResourceManager.GetString("XmlTraceListenerDataTypeNameDisplayName", resourceCulture);
            }
        }
    }
}
