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

namespace Bicep.Core {
    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", "17.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class CoreResources {

        private static global::System.Resources.ResourceManager resourceMan;

        private static global::System.Globalization.CultureInfo resourceCulture;

        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal CoreResources() {
        }

        /// <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("Bicep.Core.CoreResources", typeof(CoreResources).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 Property &apos;adminUserName&apos; should not use a literal value. Use a param instead..
        /// </summary>
        internal static string AdminUsernameShouldNotBeLiteralRuleDescription {
            get {
                return ResourceManager.GetString("AdminUsernameShouldNotBeLiteralRuleDescription", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to If an &apos;{0}&apos; parameter is provided, an &apos;{1}&apos; parameter must also be provided..
        /// </summary>
        internal static string ArtifactsLocationRule_Error_ParamMissing {
            get {
                return ResourceManager.GetString("ArtifactsLocationRule_Error_ParamMissing", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Artifacts parameter &apos;{0}&apos; must use the @secure() attribute.
        /// </summary>
        internal static string ArtifactsLocationRule_Error_ParamMustBeSecure {
            get {
                return ResourceManager.GetString("ArtifactsLocationRule_Error_ParamMustBeSecure", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Artifacts parameter &apos;{0}&apos; must be of type &apos;{1}&apos;.
        /// </summary>
        internal static string ArtifactsLocationRule_Error_ParamMustBeType {
            get {
                return ResourceManager.GetString("ArtifactsLocationRule_Error_ParamMustBeType", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Change parameter type to &apos;{0}&apos;.
        /// </summary>
        internal static string ArtifactsLocationRule_FixTitle_ChangeType {
            get {
                return ResourceManager.GetString("ArtifactsLocationRule_FixTitle_ChangeType", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Custom bicepconfig.json file found ({0})..
        /// </summary>
        internal static string BicepConfigCustomSettingsFoundFormatMessage {
            get {
                return ResourceManager.GetString("BicepConfigCustomSettingsFoundFormatMessage", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to No bicepconfig.json found for configuration override..
        /// </summary>
        internal static string BicepConfigNoCustomSettingsMessage {
            get {
                return ResourceManager.GetString("BicepConfigNoCustomSettingsMessage", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Some decompiler imperfections may need to be cleaned up manually.
        /// </summary>
        internal static string DecompilerImperfectionsRule_Description {
            get {
                return ResourceManager.GetString("DecompilerImperfectionsRule_Description", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Consider renaming it and removing the suffix (using the editor&apos;s rename functionality)..
        /// </summary>
        internal static string DecompilerImperfectionsRule_MayWantToRename {
            get {
                return ResourceManager.GetString("DecompilerImperfectionsRule_MayWantToRename", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The symbolic name of resource &apos;{0}&apos; appears to have originated from a naming conflict during a decompilation from JSON..
        /// </summary>
        internal static string DecompilerImperfectionsRule_Resource {
            get {
                return ResourceManager.GetString("DecompilerImperfectionsRule_Resource", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The name of variable &apos;{0}&apos; appears to have originated from a naming conflict during a decompilation from JSON..
        /// </summary>
        internal static string DecompilerImperfectionsRule_Variable {
            get {
                return ResourceManager.GetString("DecompilerImperfectionsRule_Variable", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Environment URLs should not be hardcoded. Use the environment() function to ensure compatibility across clouds..
        /// </summary>
        internal static string EnvironmentUrlHardcodedRuleDescription {
            get {
                return ResourceManager.GetString("EnvironmentUrlHardcodedRuleDescription", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Asserts.
        /// </summary>
        internal static string ExperimentalFeatureNames_Asserts {
            get {
                return ResourceManager.GetString("ExperimentalFeatureNames_Asserts", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to OCI registry support.
        /// </summary>
        internal static string ExperimentalFeatureNames_OciEnabled {
            get {
                return ResourceManager.GetString("ExperimentalFeatureNames_OciEnabled", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Resource info code generation.
        /// </summary>
        internal static string ExperimentalFeatureNames_ResourceInfoCodegen {
            get {
                return ResourceManager.GetString("ExperimentalFeatureNames_ResourceInfoCodegen", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Resource-typed parameters and outputs.
        /// </summary>
        internal static string ExperimentalFeatureNames_ResourceTypedParamsAndOutputs {
            get {
                return ResourceManager.GetString("ExperimentalFeatureNames_ResourceTypedParamsAndOutputs", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Source mapping.
        /// </summary>
        internal static string ExperimentalFeatureNames_SourceMapping {
            get {
                return ResourceManager.GetString("ExperimentalFeatureNames_SourceMapping", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Symbolic name code generation.
        /// </summary>
        internal static string ExperimentalFeatureNames_SymbolicNameCodegen {
            get {
                return ResourceManager.GetString("ExperimentalFeatureNames_SymbolicNameCodegen", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Test framework.
        /// </summary>
        internal static string ExperimentalFeatureNames_TestFramework {
            get {
                return ResourceManager.GetString("ExperimentalFeatureNames_TestFramework", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Enable waitUntil feature on resource bicep types.
        /// </summary>
        internal static string ExperimentalFeatureNames_WaitUntil {
            get {
                return ResourceManager.GetString("ExperimentalFeatureNames_WaitUntil", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to All imports must be used..
        /// </summary>
        internal static string ImportMustBeUsedRuleDescription {
            get {
                return ResourceManager.GetString("ImportMustBeUsedRuleDescription", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Import &quot;{0}&quot; is declared but never used..
        /// </summary>
        internal static string ImportMustBeUsedRuleMessageFormat {
            get {
                return ResourceManager.GetString("ImportMustBeUsedRuleMessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Use string interpolation.
        /// </summary>
        internal static string InterpolateNotConcatFixTitle {
            get {
                return ResourceManager.GetString("InterpolateNotConcatFixTitle", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Use string interpolation instead of the concat function..
        /// </summary>
        internal static string InterpolateNotConcatRuleDescription {
            get {
                return ResourceManager.GetString("InterpolateNotConcatRuleDescription", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Linter is disabled in settings file located at {0} .
        /// </summary>
        internal static string LinterDisabledFormatMessage {
            get {
                return ResourceManager.GetString("LinterDisabledFormatMessage", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Analyzer &apos;{0}&apos; encountered an unexpected exception. {1}.
        /// </summary>
        internal static string LinterRuleExceptionMessageFormat {
            get {
                return ResourceManager.GetString("LinterRuleExceptionMessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Resource location should be specified by a parameter without a default value or one that defaults to &apos;global&apos; or resourceGroup().location..
        /// </summary>
        internal static string LocationSetByParameterRuleDescription {
            get {
                return ResourceManager.GetString("LocationSetByParameterRuleDescription", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Maximum number of &apos;assert&apos; statements used..
        /// </summary>
        internal static string MaxNumberAssertsRuleDescription {
            get {
                return ResourceManager.GetString("MaxNumberAssertsRuleDescription", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Too many predeployment conditions. Number of &apos;assert&apos; statements is limited to {0}..
        /// </summary>
        internal static string MaxNumberAssertsRuleMessageFormat {
            get {
                return ResourceManager.GetString("MaxNumberAssertsRuleMessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Maximum number of outputs used..
        /// </summary>
        internal static string MaxNumberOutputsRuleDescription {
            get {
                return ResourceManager.GetString("MaxNumberOutputsRuleDescription", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Too many outputs. Number of outputs is limited to {0}..
        /// </summary>
        internal static string MaxNumberOutputsRuleMessageFormat {
            get {
                return ResourceManager.GetString("MaxNumberOutputsRuleMessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Maximum number of parameters used..
        /// </summary>
        internal static string MaxNumberParametersRuleDescription {
            get {
                return ResourceManager.GetString("MaxNumberParametersRuleDescription", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Too many parameters. Number of parameters is limited to {0}..
        /// </summary>
        internal static string MaxNumberParametersRuleMessageFormat {
            get {
                return ResourceManager.GetString("MaxNumberParametersRuleMessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Maximum number of resources used..
        /// </summary>
        internal static string MaxNumberResourcesRuleDescription {
            get {
                return ResourceManager.GetString("MaxNumberResourcesRuleDescription", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Too many resources. Number of resources is limited to {0}..
        /// </summary>
        internal static string MaxNumberResourcesRuleMessageFormat {
            get {
                return ResourceManager.GetString("MaxNumberResourcesRuleMessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Maximum number of variables used..
        /// </summary>
        internal static string MaxNumberVariablesRuleDescription {
            get {
                return ResourceManager.GetString("MaxNumberVariablesRuleDescription", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Too many variables. Number of variables is limited to {0}..
        /// </summary>
        internal static string MaxNumberVariablesRuleMessageFormat {
            get {
                return ResourceManager.GetString("MaxNumberVariablesRuleMessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Metadata properties whose value is set by a separate decorator should not be set via the &apos;@metadata()&apos; decorator..
        /// </summary>
        internal static string NoConflictingMetadataRuleDescription {
            get {
                return ResourceManager.GetString("NoConflictingMetadataRuleDescription", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The &quot;{0}&quot; metadata property conflicts with the &quot;{1}&quot; decorator and will be overwritten..
        /// </summary>
        internal static string NoConflictingMetadataRuleMessageFormat {
            get {
                return ResourceManager.GetString("NoConflictingMetadataRuleMessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Bicep modules are recommended instead of representing nested or linked deployments as a resource..
        /// </summary>
        internal static string NoDeploymentsResourcesRuleDescription {
            get {
                return ResourceManager.GetString("NoDeploymentsResourcesRuleDescription", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Resource &apos;{0}&apos; of type &apos;{1}&apos; should instead be declared as a Bicep module..
        /// </summary>
        internal static string NoDeploymentsResourcesRuleMessageFormat {
            get {
                return ResourceManager.GetString("NoDeploymentsResourcesRuleMessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Avoid using an explicit &apos;any&apos; type whenever possible..
        /// </summary>
        internal static string NoExplicitAnyRule_Description {
            get {
                return ResourceManager.GetString("NoExplicitAnyRule_Description", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to A resource location should not use a hard-coded string or variable value. Change variable &apos;{0}&apos; into a parameter instead..
        /// </summary>
        internal static string NoHardcodedLocation_ErrorChangeVarToParam {
            get {
                return ResourceManager.GetString("NoHardcodedLocation_ErrorChangeVarToParam", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Parameter &apos;{0}&apos; may be used as a resource location in the module and should not be assigned a hard-coded string or variable value..
        /// </summary>
        internal static string NoHardcodedLocation_ErrorForModuleParam {
            get {
                return ResourceManager.GetString("NoHardcodedLocation_ErrorForModuleParam", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to A resource location should not use a hard-coded string or variable value..
        /// </summary>
        internal static string NoHardcodedLocation_ErrorForResourceLocation {
            get {
                return ResourceManager.GetString("NoHardcodedLocation_ErrorForResourceLocation", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Please use a parameter value, an expression, or the string &apos;{0}&apos;. Found: &apos;{1}&apos;.
        /// </summary>
        internal static string NoHardcodedLocation_ErrorSolution {
            get {
                return ResourceManager.GetString("NoHardcodedLocation_ErrorSolution", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Change variable &apos;{0}&apos; into a parameter instead.
        /// </summary>
        internal static string NoHardcodedLocation_FixChangeVarToParam {
            get {
                return ResourceManager.GetString("NoHardcodedLocation_FixChangeVarToParam", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Create new parameter &apos;{0}&apos; with default value {1}.
        /// </summary>
        internal static string NoHardcodedLocation_FixNewParam {
            get {
                return ResourceManager.GetString("NoHardcodedLocation_FixNewParam", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Parameter &apos;{0}&apos; of module &apos;{1}&apos; isn&apos;t assigned an explicit value, and its default value may not give the intended behavior for a location-related parameter. You should assign an explicit value to the parameter..
        /// </summary>
        internal static string NoHardcodedLocation_ModuleLocationNeedsExplicitValue {
            get {
                return ResourceManager.GetString("NoHardcodedLocation_ModuleLocationNeedsExplicitValue", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to A resource location should be either an expression or the string &apos;{0}&apos;. Found &apos;{1}&apos;.
        /// </summary>
        internal static string NoHardcodedLocation_ResourceLocationShouldBeExpressionOrGlobal {
            get {
                return ResourceManager.GetString("NoHardcodedLocation_ResourceLocationShouldBeExpressionOrGlobal", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to A resource&apos;s location should not use a hard-coded string or variable value. It should use a parameter, an expression, or the string &apos;global&apos;..
        /// </summary>
        internal static string NoHardcodedLocationRuleDescription {
            get {
                return ResourceManager.GetString("NoHardcodedLocationRuleDescription", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Outputs should not be used for hard-coded constants. Use exported variables instead..
        /// </summary>
        internal static string NoHardcodedOutputsRuleDescription {
            get {
                return ResourceManager.GetString("NoHardcodedOutputsRuleDescription", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Create exported variable &apos;{0}&apos; and remove output &apos;{1}&apos;.
        /// </summary>
        internal static string NoHardcodedOutputsRuleFixTitle {
            get {
                return ResourceManager.GetString("NoHardcodedOutputsRuleFixTitle", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Output &apos;{0}&apos; uses a hard-coded value. Use an exported variable for constants that need to be imported by other files..
        /// </summary>
        internal static string NoHardcodedOutputsRuleMessageFormat {
            get {
                return ResourceManager.GetString("NoHardcodedOutputsRuleMessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Functions resourceGroup().location and deployment().location should only be used as the default value of a parameter..
        /// </summary>
        internal static string NoLocExprOutsideParamsRuleDescription {
            get {
                return ResourceManager.GetString("NoLocExprOutsideParamsRuleDescription", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Use a parameter here instead of &apos;{0}&apos;. &apos;resourceGroup().location&apos; and &apos;deployment().location&apos; should only be used as a default value for parameters..
        /// </summary>
        internal static string NoLocExprOutsideParamsRuleError {
            get {
                return ResourceManager.GetString("NoLocExprOutsideParamsRuleError", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Nested deployment resources cannot refer to top-level symbols from within the &apos;template&apos; property when inner-scoped evaluation is used..
        /// </summary>
        internal static string NoSymbolicReferencesInInnerScopedDeploymentResourcesDescription {
            get {
                return ResourceManager.GetString("NoSymbolicReferencesInInnerScopedDeploymentResourcesDescription", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The symbol &quot;{0}&quot; is declared in the context of the outer deployment and cannot be accessed by expressions within a nested deployment template that uses inner scoping for expression evaluation..
        /// </summary>
        internal static string NoSymbolicReferencesInInnerScopedDeploymentResourcesMessageFormat {
            get {
                return ResourceManager.GetString("NoSymbolicReferencesInInnerScopedDeploymentResourcesMessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Remove unnecessary dependsOn.
        /// </summary>
        internal static string NoUnnecessaryDependsOnRuleCodeFix {
            get {
                return ResourceManager.GetString("NoUnnecessaryDependsOnRuleCodeFix", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to No unnecessary dependsOn..
        /// </summary>
        internal static string NoUnnecessaryDependsOnRuleDescription {
            get {
                return ResourceManager.GetString("NoUnnecessaryDependsOnRuleDescription", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Remove unnecessary dependsOn entry &apos;{0}&apos;..
        /// </summary>
        internal static string NoUnnecessaryDependsOnRuleMessage {
            get {
                return ResourceManager.GetString("NoUnnecessaryDependsOnRuleMessage", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to function &apos;{0}&apos;.
        /// </summary>
        internal static string OutputsShouldNotContainSecretsFunction {
            get {
                return ResourceManager.GetString("OutputsShouldNotContainSecretsFunction", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to {0} Found possible secret: {1}.
        /// </summary>
        internal static string OutputsShouldNotContainSecretsMessageFormat {
            get {
                return ResourceManager.GetString("OutputsShouldNotContainSecretsMessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to output name &apos;{0}&apos; suggests a secret.
        /// </summary>
        internal static string OutputsShouldNotContainSecretsOutputName {
            get {
                return ResourceManager.GetString("OutputsShouldNotContainSecretsOutputName", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Outputs should not contain secrets..
        /// </summary>
        internal static string OutputsShouldNotContainSecretsRuleDescription {
            get {
                return ResourceManager.GetString("OutputsShouldNotContainSecretsRuleDescription", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to secure value &apos;{0}&apos;.
        /// </summary>
        internal static string OutputsShouldNotContainSecretsSecureParam {
            get {
                return ResourceManager.GetString("OutputsShouldNotContainSecretsSecureParam", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to All parameters must be used..
        /// </summary>
        internal static string ParameterMustBeUsedRuleDescription {
            get {
                return ResourceManager.GetString("ParameterMustBeUsedRuleDescription", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Parameter &quot;{0}&quot; is declared but never used..
        /// </summary>
        internal static string ParameterMustBeUsedRuleMessageFormat {
            get {
                return ResourceManager.GetString("ParameterMustBeUsedRuleMessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to function &apos;{0}&apos;.
        /// </summary>
        internal static string PossibleSecretMessageFunction {
            get {
                return ResourceManager.GetString("PossibleSecretMessageFunction", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to secure value &apos;{0}&apos;.
        /// </summary>
        internal static string PossibleSecretMessageSecureParam {
            get {
                return ResourceManager.GetString("PossibleSecretMessageSecureParam", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Remove quotes from property name &apos;{0}&apos;.
        /// </summary>
        internal static string PreferUnquotedPropertyNames_DeclarationFixTitle {
            get {
                return ResourceManager.GetString("PreferUnquotedPropertyNames_DeclarationFixTitle", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Replace array syntax with &apos;{0}&apos;.
        /// </summary>
        internal static string PreferUnquotedPropertyNames_DereferenceFixTitle {
            get {
                return ResourceManager.GetString("PreferUnquotedPropertyNames_DereferenceFixTitle", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Property names that are valid identifiers should be declared without quotation marks and accessed using dot notation..
        /// </summary>
        internal static string PreferUnquotedPropertyNamesRule_Description {
            get {
                return ResourceManager.GetString("PreferUnquotedPropertyNamesRule_Description", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Use protectedSettings for commandToExecute secrets.
        /// </summary>
        internal static string ProtectCommandToExecuteSecretsRuleDescription {
            get {
                return ResourceManager.GetString("ProtectCommandToExecuteSecretsRuleDescription", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Use protectedSettings for commandToExecute secrets. Found possible secret: {0}.
        /// </summary>
        internal static string ProtectCommandToExecuteSecretsRuleMessage {
            get {
                return ResourceManager.GetString("ProtectCommandToExecuteSecretsRuleMessage", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Parameters that represent secrets must be secure..
        /// </summary>
        internal static string SecretsInParamsRule_Description {
            get {
                return ResourceManager.GetString("SecretsInParamsRule_Description", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Parameter &apos;{0}&apos; may represent a secret (according to its name) and must be declared with the &apos;@secure()&apos; attribute..
        /// </summary>
        internal static string SecretsInParamsRule_MessageFormat {
            get {
                return ResourceManager.GetString("SecretsInParamsRule_MessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Remove insecure default value.
        /// </summary>
        internal static string SecureParameterDefaultFixTitle {
            get {
                return ResourceManager.GetString("SecureParameterDefaultFixTitle", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Secure parameters should not have hardcoded defaults (except for empty or newGuid())..
        /// </summary>
        internal static string SecureParameterDefaultRuleDescription {
            get {
                return ResourceManager.GetString("SecureParameterDefaultRuleDescription", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Outer-scoped nested deployment resources should not be used for secure parameters or list* functions..
        /// </summary>
        internal static string SecureParamsInNestedDeployRule_Description {
            get {
                return ResourceManager.GetString("SecureParamsInNestedDeployRule_Description", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; is an outer scoped nested deployment that calls a list* function (&quot;{1}&quot;), which could expose sensitive values in deployment history..
        /// </summary>
        internal static string SecureParamsInNestedDeployRule_Message_ListFunction {
            get {
                return ResourceManager.GetString("SecureParamsInNestedDeployRule_Message_ListFunction", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; is an outer scoped nested deployment that accesses secure string parameters ({1}), which could expose their values in deployment history..
        /// </summary>
        internal static string SecureParamsInNestedDeployRule_Message_SecureParams {
            get {
                return ResourceManager.GetString("SecureParamsInNestedDeployRule_Message_SecureParams", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Secure parameter values should not be assigned to insecure parameters in a parameters file..
        /// </summary>
        internal static string SecureParamsInParametersFileRule_Description {
            get {
                return ResourceManager.GetString("SecureParamsInParametersFileRule_Description", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Insecure parameter &apos;{0}&apos; is assigned a value that references secure parameter(s) {1}, which could expose their values in deployment history..
        /// </summary>
        internal static string SecureParamsInParametersFileRule_MessageFormat {
            get {
                return ResourceManager.GetString("SecureParamsInParametersFileRule_MessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Either set the deployment&apos;s properties.expressionEvaluationOptions.scope to &apos;inner&apos; or use a Bicep module instead..
        /// </summary>
        internal static string SecureParamsInNestedDeployRule_Solution {
            get {
                return ResourceManager.GetString("SecureParamsInNestedDeployRule_Solution", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Remove unnecessary string interpolation.
        /// </summary>
        internal static string SimplifyInterpolationFixTitle {
            get {
                return ResourceManager.GetString("SimplifyInterpolationFixTitle", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Remove unnecessary string interpolation..
        /// </summary>
        internal static string SimplifyInterpolationRuleDescription {
            get {
                return ResourceManager.GetString("SimplifyInterpolationRuleDescription", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Simplify json(&apos;null&apos;) to null.
        /// </summary>
        internal static string SimplifyJsonNullFixTitle {
            get {
                return ResourceManager.GetString("SimplifyJsonNullFixTitle", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Simplify json(&apos;null&apos;) to null.
        /// </summary>
        internal static string SimplifyJsonNullRuleDescription {
            get {
                return ResourceManager.GetString("SimplifyJsonNullRuleDescription", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Non-secure config property values must be a value type to be valid for Deployment stack deployments..
        /// </summary>
        internal static string StacksExtensibilityCompatibilityRule_NonSecurePropertyValueIsReference {
            get {
                return ResourceManager.GetString("StacksExtensibilityCompatibilityRule_NonSecurePropertyValueIsReference", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Secure config property values must be a key vault reference to be valid for Deployment stack deployments..
        /// </summary>
        internal static string StacksExtensibilityCompatibilityRule_SecurePropertyValueIsNotReference {
            get {
                return ResourceManager.GetString("StacksExtensibilityCompatibilityRule_SecurePropertyValueIsNotReference", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Extensibility for deployments has additional constraints for Deployment stack deployments..
        /// </summary>
        internal static string StacksExtensibilityCompatibilityRuleDescription {
            get {
                return ResourceManager.GetString("StacksExtensibilityCompatibilityRuleDescription", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to All existing resources must be used..
        /// </summary>
        internal static string UnusedExistingResourceRuleDescription {
            get {
                return ResourceManager.GetString("UnusedExistingResourceRuleDescription", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Existing resource &quot;{0}&quot; is declared but never used..
        /// </summary>
        internal static string UnusedExistingResourceRuleMessageFormat {
            get {
                return ResourceManager.GetString("UnusedExistingResourceRuleMessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to All variables must be used..
        /// </summary>
        internal static string UnusedVariableRuleDescription {
            get {
                return ResourceManager.GetString("UnusedVariableRuleDescription", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Variable &quot;{0}&quot; is declared but never used..
        /// </summary>
        internal static string UnusedVariableRuleMessageFormat {
            get {
                return ResourceManager.GetString("UnusedVariableRuleMessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to All declared types must be used..
        /// </summary>
        internal static string UnusedTypeRuleDescription {
            get {
                return ResourceManager.GetString("UnusedTypeRuleDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &quot;{0}&quot; is declared but never used..
        /// </summary>
        internal static string UnusedTypeRuleMessageFormat {
            get {
                return ResourceManager.GetString("UnusedTypeRuleMessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Use parent property.
        /// </summary>
        internal static string UseParentPropertyRule_CodeFix {
            get {
                return ResourceManager.GetString("UseParentPropertyRule_CodeFix", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Use the parent property instead of formatting child resource names with &apos;/&apos; characters..
        /// </summary>
        internal static string UseParentPropertyRule_Description {
            get {
                return ResourceManager.GetString("UseParentPropertyRule_Description", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Resource &quot;{0}&quot; has its name formatted as a child of resource &quot;{1}&quot;. The syntax can be simplified by using the parent property..
        /// </summary>
        internal static string UseParentPropertyRule_MessageFormat {
            get {
                return ResourceManager.GetString("UseParentPropertyRule_MessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Acceptable versions: {0}.
        /// </summary>
        internal static string UseRecentApiVersionRule_AcceptableVersions {
            get {
                return ResourceManager.GetString("UseRecentApiVersionRule_AcceptableVersions", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Use recent API versions.
        /// </summary>
        internal static string UseRecentApiVersionRule_Description {
            get {
                return ResourceManager.GetString("UseRecentApiVersionRule_Description", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Use more recent API version for &apos;{0}&apos;. {1}.
        /// </summary>
        internal static string UseRecentApiVersionRule_ErrorMessageFormat {
            get {
                return ResourceManager.GetString("UseRecentApiVersionRule_ErrorMessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Replace with {0}.
        /// </summary>
        internal static string UseRecentApiVersionRule_Fix_ReplaceApiVersion {
            get {
                return ResourceManager.GetString("UseRecentApiVersionRule_Fix_ReplaceApiVersion", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; is a preview version and there is a more recent non-preview version available..
        /// </summary>
        internal static string UseRecentApiVersionRule_MoreRecentStable {
            get {
                return ResourceManager.GetString("UseRecentApiVersionRule_MoreRecentStable", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; is a preview version and there is a non-preview version available with the same date..
        /// </summary>
        internal static string UseRecentApiVersionRule_StableWithSameDate {
            get {
                return ResourceManager.GetString("UseRecentApiVersionRule_StableWithSameDate", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; is {1} days old, should be no more than {2} days old, or the most recent..
        /// </summary>
        internal static string UseRecentApiVersionRule_TooOld {
            get {
                return ResourceManager.GetString("UseRecentApiVersionRule_TooOld", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Could not find resource type &quot;{0}&quot;..
        /// </summary>
        internal static string UseRecentApiVersionRule_UnknownType {
            get {
                return ResourceManager.GetString("UseRecentApiVersionRule_UnknownType", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Did you mean &quot;{0}&quot;?.
        /// </summary>
        internal static string UseRecentApiVersionRule_UnknownTypeSuggestion {
            get {
                return ResourceManager.GetString("UseRecentApiVersionRule_UnknownTypeSuggestion", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Could not find apiVersion {0} for {1}..
        /// </summary>
        internal static string UseRecentApiVersionRule_UnknownVersion {
            get {
                return ResourceManager.GetString("UseRecentApiVersionRule_UnknownVersion", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Use AzPowerShell version 11.0 or higher in deployment scripts to avoid EOL Ubuntu 20.04 LTS.
        /// </summary>
        internal static string UseRecentAzPowerShellVersionRuleDescription {
            get {
                return ResourceManager.GetString("UseRecentAzPowerShellVersionRuleDescription", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Deployment script is using AzPowerShell version &apos;{0}&apos; which is below the recommended minimum version &apos;{1}&apos;. Consider upgrading to version 11.0 or higher to avoid EOL Ubuntu 20.04 LTS..
        /// </summary>
        internal static string UseRecentAzPowerShellVersionRuleMessageFormat {
            get {
                return ResourceManager.GetString("UseRecentAzPowerShellVersionRuleMessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Could not download available module versions: {0}.
        /// </summary>
        internal static string UseRecentModulesVersionRule_CouldNotDownload {
            get {
                return ResourceManager.GetString("UseRecentModulesVersionRule_CouldNotDownload", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The most recent version is {0}..
        /// </summary>
        internal static string UseRecentModulesVersionRule_MostRecentVersion {
            get {
                return ResourceManager.GetString("UseRecentModulesVersionRule_MostRecentVersion", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Available module versions have not yet been downloaded. If running from the command line, be sure --no-restore is not specified..
        /// </summary>
        internal static string UseRecentModulesVersionRule_NotCached {
            get {
                return ResourceManager.GetString("UseRecentModulesVersionRule_NotCached", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Use a more recent version of module &apos;{0}&apos;..
        /// </summary>
        internal static string UseRecentModuleVersionRule_ErrorMessageFormat {
            get {
                return ResourceManager.GetString("UseRecentModuleVersionRule_ErrorMessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Replace with most recent version &apos;{0}&apos;.
        /// </summary>
        internal static string UseRecentModuleVersionRule_Fix_ReplaceWithMostRecent {
            get {
                return ResourceManager.GetString("UseRecentModuleVersionRule_Fix_ReplaceWithMostRecent", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Use recent module versions.
        /// </summary>
        internal static string UseRecentModuleVersionsRule_Description {
            get {
                return ResourceManager.GetString("UseRecentModuleVersionsRule_Description", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Properties representing a resource ID must be generated appropriately..
        /// </summary>
        internal static string UseResourceIdFunctionsRule_Description {
            get {
                return ResourceManager.GetString("UseResourceIdFunctionsRule_Description", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to If property &quot;{0}&quot; represents a resource ID, it must use a symbolic resource reference, be a parameter or start with one of these functions: {1}..
        /// </summary>
        internal static string UseResourceIdFunctionsRule_MessageFormat {
            get {
                return ResourceManager.GetString("UseResourceIdFunctionsRule_MessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Found nonconforming expression at {0}.
        /// </summary>
        internal static string UseResourceIdFunctionsRule_NonConformingExprPath {
            get {
                return ResourceManager.GetString("UseResourceIdFunctionsRule_NonConformingExprPath", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Use direct resource reference.
        /// </summary>
        internal static string UseResourceSymbolReferenceRule_CodeFix {
            get {
                return ResourceManager.GetString("UseResourceSymbolReferenceRule_CodeFix", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Use a direct resource symbol reference instead of &apos;reference&apos; or &apos;list*&apos; functions..
        /// </summary>
        internal static string UseResourceSymbolReferenceRule_Description {
            get {
                return ResourceManager.GetString("UseResourceSymbolReferenceRule_Description", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Use a resource reference instead of invoking function &quot;{0}&quot;. This simplifies the syntax and allows Bicep to better understand your deployment dependency graph..
        /// </summary>
        internal static string UseResourceSymbolReferenceRule_MessageFormat {
            get {
                return ResourceManager.GetString("UseResourceSymbolReferenceRule_MessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Use the safe access (.?) operator.
        /// </summary>
        internal static string UseSafeAccessRule_CodeFix {
            get {
                return ResourceManager.GetString("UseSafeAccessRule_CodeFix", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The syntax can be simplified by using the safe access (.?) operator..
        /// </summary>
        internal static string UseSafeAccessRule_ContainsReplacement_MessageFormat {
            get {
                return ResourceManager.GetString("UseSafeAccessRule_ContainsReplacement_MessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Use the safe access (.?) operator..
        /// </summary>
        internal static string UseSafeAccessRule_Description {
            get {
                return ResourceManager.GetString("UseSafeAccessRule_Description", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The property being accessed may be null. Use the (.?) operator to handle this safely..
        /// </summary>
        internal static string UseSafeAccessRule_NullCheckReplacement_MessageFormat {
            get {
                return ResourceManager.GetString("UseSafeAccessRule_NullCheckReplacement_MessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Resource properties expecting secure input should be assigned secure values..
        /// </summary>
        internal static string UseSecureValueForSecureInputsRule_Description {
            get {
                return ResourceManager.GetString("UseSecureValueForSecureInputsRule_Description", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Property &apos;{0}&apos; expects a secure value, but the value provided may not be secure..
        /// </summary>
        internal static string UseSecureValueForSecureInputsRule_MessageFormat {
            get {
                return ResourceManager.GetString("UseSecureValueForSecureInputsRule_MessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Resource identifiers should be reproducible outside of their initial deployment context. .
        /// </summary>
        internal static string UseStableResourceIdentifiersMessage {
            get {
                return ResourceManager.GetString("UseStableResourceIdentifiersMessage", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Resource identifiers should be reproducible outside of their initial deployment context. Resource {0}&apos;s &apos;{1}&apos; identifier is potentially nondeterministic due to its use of the &apos;{2}&apos; function ({3})..
        /// </summary>
        internal static string UseStableResourceIdentifiersMessageFormat {
            get {
                return ResourceManager.GetString("UseStableResourceIdentifiersMessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Virtual machines shouldn&apos;t use preview images..
        /// </summary>
        internal static string UseStableVMImage {
            get {
                return ResourceManager.GetString("UseStableVMImage", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Virtual machines shouldn&apos;t use preview images. Use stable version in imageReference property &quot;{0}&quot;..
        /// </summary>
        internal static string UseStableVMImageRuleFixMessageFormat {
            get {
                return ResourceManager.GetString("UseStableVMImageRuleFixMessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Use user-defined types instead of &apos;object&apos; or &apos;array&apos;..
        /// </summary>
        internal static string UseUserDefinedTypesRule_Description {
            get {
                return ResourceManager.GetString("UseUserDefinedTypesRule_Description", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Runtime values should not be used to determine resource IDs.
        /// </summary>
        internal static string WhatIfShortCircuitingRuleDescription {
            get {
                return ResourceManager.GetString("WhatIfShortCircuitingRuleDescription", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Parameter &apos;{0}&apos; is used as a resource identifier, API version, or condition in the module &apos;{1}&apos;. Providing a runtime value for this parameter will lead to short-circuiting or less precise predictions in What-If..
        /// </summary>
        internal static string WhatIfShortCircuitingRuleMessageFormat {
            get {
                return ResourceManager.GetString("WhatIfShortCircuitingRuleMessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Warn if a &apos;reference&apos; or &apos;list*&apos; function call uses an unrecognized resource type..
        /// </summary>
        internal static string UseRecognizedResourceTypeRule_Description {
            get {
                return ResourceManager.GetString("UseRecognizedResourceTypeRule_Description", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Resource type &quot;{0}&quot; is not recognized in function &quot;{1}&quot;. If this resource type does exist, the API version must be specified as a function argument..
        /// </summary>
        internal static string UseRecognizedResourceTypeRule_MessageFormat {
            get {
                return ResourceManager.GetString("UseRecognizedResourceTypeRule_MessageFormat", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Resource type &quot;{0}&quot; is not recognized in function &quot;{1}&quot;. Did you mean &quot;{2}&quot;? If this resource type does exist, the API version must be specified as a function argument..
        /// </summary>
        internal static string UseRecognizedResourceTypeRule_MessageFormatWithSuggestion {
            get {
                return ResourceManager.GetString("UseRecognizedResourceTypeRule_MessageFormatWithSuggestion", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Avoid specifying an explicit module name. This simplifies code, and avoids the risk of accidental module name re-use within a deployment..
        /// </summary>
        internal static string NoModuleNameRule_Description {
            get {
                return ResourceManager.GetString("NoModuleNameRule_Description", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Remove module name.
        /// </summary>
        internal static string NoModuleNameRule_CodeFix {
            get {
                return ResourceManager.GetString("NoModuleNameRule_CodeFix", resourceCulture);
            }
        }
    }
}
