InspectionResults.Designer.cs

//------------------------------------------------------------------------------
// <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 Rubberduck.Resources.Inspections {
    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()]
    public class InspectionResults {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal InspectionResults() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        public static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Rubberduck.Resources.Inspections.InspectionResults", typeof(InspectionResults).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)]
        public static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} ({1} results).
        /// </summary>
        public static string AggregateInspection {
            get {
                return ResourceManager.GetString("AggregateInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use of late bound &apos;Application.{0}&apos; member..
        /// </summary>
        public static string ApplicationWorksheetFunctionInspection {
            get {
                return ResourceManager.GetString("ApplicationWorksheetFunctionInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The argument &apos;{2}&apos; of type &apos;{3}&apos; is passed to the parameter &apos;{0}&apos; of the incompatible type &apos;{1}&apos;..
        /// </summary>
        public static string ArgumentWithIncompatibleObjectTypeInspection {
            get {
                return ResourceManager.GetString("ArgumentWithIncompatibleObjectTypeInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Parameter &apos;{0}&apos; is passed &apos;ByVal&apos; and assigned a value..
        /// </summary>
        public static string AssignedByValParameterInspection {
            get {
                return ResourceManager.GetString("AssignedByValParameterInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An assignment is immediately overridden by another assignment or is never referenced..
        /// </summary>
        public static string AssignmentNotUsedInspection {
            get {
                return ResourceManager.GetString("AssignmentNotUsedInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The attribute value(s) for attribute {0} ({1}) are out of sync with the {2} annotation..
        /// </summary>
        public static string AttributeValueOutOfSyncInspection {
            get {
                return ResourceManager.GetString("AttributeValueOutOfSyncInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Boolean literal &apos;{0}&apos; assigned in conditional.
        /// </summary>
        public static string BooleanAssignedInIfElseInspection {
            get {
                return ResourceManager.GetString("BooleanAssignedInIfElseInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The expression &apos;{0}&apos; requires a default member access, but the type &apos;{1}&apos; does not have a suitable default member..
        /// </summary>
        public static string DefaultMemberRequiredInspection {
            get {
                return ResourceManager.GetString("DefaultMemberRequiredInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Project &apos;{0}&apos; has the default project name..
        /// </summary>
        public static string DefaultProjectNameInspection {
            get {
                return ResourceManager.GetString("DefaultProjectNameInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Consider the explicit use of &apos;As {0}&apos; instead of &apos;{1}&apos;..
        /// </summary>
        public static string DefTypeStatementInspection {
            get {
                return ResourceManager.GetString("DefTypeStatementInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Annotation &apos;{0}&apos; is duplicated..
        /// </summary>
        public static string DuplicatedAnnotationInspection {
            get {
                return ResourceManager.GetString("DuplicatedAnnotationInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;Case&apos; block contains no executable statements..
        /// </summary>
        public static string EmptyCaseBlockInspection {
            get {
                return ResourceManager.GetString("EmptyCaseBlockInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;Do...While&apos; loop contains no executable statements..
        /// </summary>
        public static string EmptyDoWhileBlockInspection {
            get {
                return ResourceManager.GetString("EmptyDoWhileBlockInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;Else&apos; block contains no executable statements..
        /// </summary>
        public static string EmptyElseBlockInspection {
            get {
                return ResourceManager.GetString("EmptyElseBlockInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;For...Each&apos; loop contains no executable statements..
        /// </summary>
        public static string EmptyForEachBlockInspection {
            get {
                return ResourceManager.GetString("EmptyForEachBlockInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;For...Next&apos; loop contains no executable statements..
        /// </summary>
        public static string EmptyForLoopBlockInspection {
            get {
                return ResourceManager.GetString("EmptyForLoopBlockInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;If&apos; block contains no executable statements..
        /// </summary>
        public static string EmptyIfBlockInspection {
            get {
                return ResourceManager.GetString("EmptyIfBlockInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} &apos;{1}&apos; contains no executable statements..
        /// </summary>
        public static string EmptyMethodInspection {
            get {
                return ResourceManager.GetString("EmptyMethodInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Module/class &apos;{0}&apos; is empty..
        /// </summary>
        public static string EmptyModuleInspection {
            get {
                return ResourceManager.GetString("EmptyModuleInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;vbNullString&apos; preferred to empty string literals..
        /// </summary>
        public static string EmptyStringLiteralInspection {
            get {
                return ResourceManager.GetString("EmptyStringLiteralInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;While...Wend&apos; loop contains no executable statements..
        /// </summary>
        public static string EmptyWhileWendBlockInspection {
            get {
                return ResourceManager.GetString("EmptyWhileWendBlockInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Public field &apos;{0}&apos; breaks encapsulation..
        /// </summary>
        public static string EncapsulatePublicFieldInspection {
            get {
                return ResourceManager.GetString("EncapsulatePublicFieldInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Result of &apos;{0}&apos; call is not tested for &apos;Nothing&apos;..
        /// </summary>
        public static string ExcelMemberMayReturnNothingInspection {
            get {
                return ResourceManager.GetString("ExcelMemberMayReturnNothingInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; is hidden by a valid Excel cell reference..
        /// </summary>
        public static string ExcelUdfNameIsValidCellReferenceInspection {
            get {
                return ResourceManager.GetString("ExcelUdfNameIsValidCellReferenceInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Return value of function &apos;{0}&apos; is never used..
        /// </summary>
        public static string FunctionReturnValueAlwaysDiscardedInspection {
            get {
                return ResourceManager.GetString("FunctionReturnValueAlwaysDiscardedInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Return value of function &apos;{0}&apos; gets discarded..
        /// </summary>
        public static string FunctionReturnValueDiscardedInspection {
            get {
                return ResourceManager.GetString("FunctionReturnValueDiscardedInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Expression &apos;{0}&apos; cannot be validated at compile-time..
        /// </summary>
        public static string HostSpecificExpressionInspection {
            get {
                return ResourceManager.GetString("HostSpecificExpressionInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Consider renaming {0} &apos;{1}&apos;..
        /// </summary>
        public static string IdentifierNameInspection {
            get {
                return ResourceManager.GetString("IdentifierNameInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} &apos;{1}&apos; is not used..
        /// </summary>
        public static string IdentifierNotUsedInspection {
            get {
                return ResourceManager.GetString("IdentifierNotUsedInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; invoked by &apos;IIf&apos; Function.
        /// </summary>
        public static string IIfSideEffectInspection {
            get {
                return ResourceManager.GetString("IIfSideEffectInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Interface class module &apos;{2}&apos; contains a concrete implementation for {0} &apos;{1}&apos;..
        /// </summary>
        public static string ImplementedInterfaceMemberInspection {
            get {
                return ResourceManager.GetString("ImplementedInterfaceMemberInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Member &apos;{0}&apos; implicitly references &apos;ActiveSheet&apos;..
        /// </summary>
        public static string ImplicitActiveSheetReferenceInspection {
            get {
                return ResourceManager.GetString("ImplicitActiveSheetReferenceInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Member &apos;{0}&apos; implicitly references &apos;ActiveWorkbook&apos;..
        /// </summary>
        public static string ImplicitActiveWorkbookReferenceInspection {
            get {
                return ResourceManager.GetString("ImplicitActiveWorkbookReferenceInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Parameter &apos;{0}&apos; is implicitly passed by reference..
        /// </summary>
        public static string ImplicitByRefModifierInspection {
            get {
                return ResourceManager.GetString("ImplicitByRefModifierInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Member &apos;{0}&apos; implicitly references the containing workbook document module..
        /// </summary>
        public static string ImplicitContainingWorkbookReferenceInspection {
            get {
                return ResourceManager.GetString("ImplicitContainingWorkbookReferenceInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Member &apos;{0}&apos; implicitly references the containing worksheet document module..
        /// </summary>
        public static string ImplicitContainingWorksheetReferenceInspection {
            get {
                return ResourceManager.GetString("ImplicitContainingWorksheetReferenceInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to On the expression &apos;{0}&apos;, there is an implicit default member access to &apos;{1}&apos;..
        /// </summary>
        public static string ImplicitDefaultMemberAccessInspection {
            get {
                return ResourceManager.GetString("ImplicitDefaultMemberAccessInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Constant &apos;{0}&apos; is implicitly typed..
        /// </summary>
        public static string ImplicitlyTypedConstInspection {
            get {
                return ResourceManager.GetString("ImplicitlyTypedConstInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Member &apos;{0}&apos; is implicitly public..
        /// </summary>
        public static string ImplicitPublicMemberInspection {
            get {
                return ResourceManager.GetString("ImplicitPublicMemberInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to On the expression &apos;{0}&apos;, there is an implicit recursive default member access to &apos;{1}&apos;..
        /// </summary>
        public static string ImplicitRecursiveDefaultMemberAccessInspection {
            get {
                return ResourceManager.GetString("ImplicitRecursiveDefaultMemberAccessInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to On the expression &apos;{0}&apos;, there is an implicit unbound default member access..
        /// </summary>
        public static string ImplicitUnboundDefaultMemberAccessInspection {
            get {
                return ResourceManager.GetString("ImplicitUnboundDefaultMemberAccessInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} &apos;{1}&apos; is implicitly &apos;Variant&apos;..
        /// </summary>
        public static string ImplicitVariantDeclarationInspection {
            get {
                return ResourceManager.GetString("ImplicitVariantDeclarationInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Return type of member &apos;{0}&apos; is implicitly &apos;Variant&apos;..
        /// </summary>
        public static string ImplicitVariantReturnTypeInspection {
            get {
                return ResourceManager.GetString("ImplicitVariantReturnTypeInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This array is inconsistently zero-based.
        /// </summary>
        public static string InconsistentArrayBaseInspection {
            get {
                return ResourceManager.GetString("InconsistentArrayBaseInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ParamArray &apos;{0}&apos; is inconsistently zero-based.
        /// </summary>
        public static string InconsistentParamArrayBaseInspection {
            get {
                return ResourceManager.GetString("InconsistentParamArrayBaseInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The expression &apos;{0}&apos; contains an indexed default member access to &apos;{1}&apos;..
        /// </summary>
        public static string IndexedDefaultMemberAccessInspection {
            get {
                return ResourceManager.GetString("IndexedDefaultMemberAccessInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The expression &apos;{0}&apos; contains an indexed recursive default member access to &apos;{1}&apos;..
        /// </summary>
        public static string IndexedRecursiveDefaultMemberAccessInspection {
            get {
                return ResourceManager.GetString("IndexedRecursiveDefaultMemberAccessInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The expression &apos;{0}&apos; contains an indexed unbound default member access..
        /// </summary>
        public static string IndexedUnboundDefaultMemberAccessInspection {
            get {
                return ResourceManager.GetString("IndexedUnboundDefaultMemberAccessInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} &apos;{1}&apos; is declared as &apos;Integer&apos;..
        /// </summary>
        public static string IntegerDataTypeInspection {
            get {
                return ResourceManager.GetString("IntegerDataTypeInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Annotation &apos;{0}&apos; is invalid in this context..
        /// </summary>
        public static string InvalidAnnotationInspection {
            get {
                return ResourceManager.GetString("InvalidAnnotationInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Annotation &apos;{0}&apos; cannot be used in a &apos;{1}&apos;..
        /// </summary>
        public static string InvalidAnnotationInspection_IncompatibleComponentType {
            get {
                return ResourceManager.GetString("InvalidAnnotationInspection_IncompatibleComponentType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Annotation &apos;{0}&apos; is used in a &apos;{1}&apos;, but is only valid in a &apos;{2}&apos;..
        /// </summary>
        public static string InvalidAnnotationInspection_NotInRequiredComponentType {
            get {
                return ResourceManager.GetString("InvalidAnnotationInspection_NotInRequiredComponentType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;IsMissing&apos; will always return false with the passed argument..
        /// </summary>
        public static string IsMissingOnInappropriateArgumentInspection {
            get {
                return ResourceManager.GetString("IsMissingOnInappropriateArgumentInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;IsMissing&apos; is passed an expression that is not an argument to the enclosing procedure..
        /// </summary>
        public static string IsMissingWithNonArgumentParameterInspection {
            get {
                return ResourceManager.GetString("IsMissingWithNonArgumentParameterInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Keyword used as an identifier for the member &apos;{0}&apos;..
        /// </summary>
        public static string KeywordsUsedAsMemberInspection {
            get {
                return ResourceManager.GetString("KeywordsUsedAsMemberInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Line continuation(s) in unexpected places..
        /// </summary>
        public static string LineContinuationBetweenKeywordsInspection {
            get {
                return ResourceManager.GetString("LineContinuationBetweenKeywordsInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Line label &apos;{0}&apos; is not used..
        /// </summary>
        public static string LineLabelNotUsedInspection {
            get {
                return ResourceManager.GetString("LineLabelNotUsedInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Member &apos;{0}&apos; was not found on the compile-time interface for type &apos;{1}&apos;..
        /// </summary>
        public static string MemberNotOnInterfaceInspection {
            get {
                return ResourceManager.GetString("MemberNotOnInterfaceInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Misleading ByRef modifier used for parameter &apos;{0}&apos; ({1})..
        /// </summary>
        public static string MisleadingByRefParameterInspection {
            get {
                return ResourceManager.GetString("MisleadingByRefParameterInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The annotation &apos;{0}&apos; was expected to have more arguments..
        /// </summary>
        public static string MissingAnnotationArgumentInspection {
            get {
                return ResourceManager.GetString("MissingAnnotationArgumentInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Module or member &apos;{0}&apos; has a &apos;{1}&apos; annotation, but no corresponding attribute..
        /// </summary>
        public static string MissingAttributeInspection {
            get {
                return ResourceManager.GetString("MissingAttributeInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Member &apos;{0}&apos; has a &apos;{1}&apos; attribute with value(s) &apos;{2}&apos;, but no corresponding annotation..
        /// </summary>
        public static string MissingMemberAnnotationInspection {
            get {
                return ResourceManager.GetString("MissingMemberAnnotationInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Module &apos;{0}&apos; has a &apos;{1}&apos; attribute with value(s) &apos;{2}&apos;, but no corresponding annotation..
        /// </summary>
        public static string MissingModuleAnnotationInspection {
            get {
                return ResourceManager.GetString("MissingModuleAnnotationInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Module-level variable &apos;{0}&apos; is declared with the &apos;Dim&apos; keyword..
        /// </summary>
        public static string ModuleScopeDimKeywordInspection {
            get {
                return ResourceManager.GetString("ModuleScopeDimKeywordInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Module &apos;{0}&apos; has no &apos;@Folder&apos; annotation..
        /// </summary>
        public static string ModuleWithoutFolderInspection {
            get {
                return ResourceManager.GetString("ModuleWithoutFolderInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Move module-level variable &apos;{0}&apos; to a smaller scope..
        /// </summary>
        public static string MoveFieldCloserToUsageInspection {
            get {
                return ResourceManager.GetString("MoveFieldCloserToUsageInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Parameter &apos;{0}&apos; is specified on multiple lines..
        /// </summary>
        public static string MultilineParameterInspection {
            get {
                return ResourceManager.GetString("MultilineParameterInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Instruction contains multiple declarations..
        /// </summary>
        public static string MultipleDeclarationsInspection {
            get {
                return ResourceManager.GetString("MultipleDeclarationsInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Negative line number encountered.
        /// </summary>
        public static string NegativeLineNumberInspection {
            get {
                return ResourceManager.GetString("NegativeLineNumberInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Non-breaking space encountered in identifier &apos;{0}&apos;..
        /// </summary>
        public static string NonBreakingSpaceIdentifierInspection {
            get {
                return ResourceManager.GetString("NonBreakingSpaceIdentifierInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Return value for member &apos;{0}&apos; is never assigned..
        /// </summary>
        public static string NonReturningFunctionInspection {
            get {
                return ResourceManager.GetString("NonReturningFunctionInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Object variable &apos;{0}&apos; is assigned without the &apos;Set&apos; keyword..
        /// </summary>
        public static string ObjectVariableNotSetInspection {
            get {
                return ResourceManager.GetString("ObjectVariableNotSetInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The expression &apos;{0}&apos; is used in a context that requires a procedure, which leads to a call to the default member &apos;{1}&apos;..
        /// </summary>
        public static string ObjectWhereProcedureIsRequiredInspection {
            get {
                return ResourceManager.GetString("ObjectWhereProcedureIsRequiredInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The expression &apos;{0}&apos; is used in a context that requires a procedure, which leads to a call to a default member that cannot be determined at compile time..
        /// </summary>
        public static string ObjectWhereProcedureIsRequiredInspection_Unbound {
            get {
                return ResourceManager.GetString("ObjectWhereProcedureIsRequiredInspection_Unbound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; is declared using the obsolete &apos;CDecl&apos; calling convention..
        /// </summary>
        public static string ObsoleteCallingConventionInspection {
            get {
                return ResourceManager.GetString("ObsoleteCallingConventionInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Assignment uses obsolete &apos;Call&apos; modifier..
        /// </summary>
        public static string ObsoleteCallStatementInspection {
            get {
                return ResourceManager.GetString("ObsoleteCallStatementInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Comment uses obsolete &apos;Rem&apos; marker..
        /// </summary>
        public static string ObsoleteCommentSyntaxInspection {
            get {
                return ResourceManager.GetString("ObsoleteCommentSyntaxInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A run-time error is raised using the obsolete &apos;Error&apos; statement..
        /// </summary>
        public static string ObsoleteErrorSyntaxInspection {
            get {
                return ResourceManager.GetString("ObsoleteErrorSyntaxInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} &apos;{1}&apos; uses obsolete &apos;Global&apos; access modifier..
        /// </summary>
        public static string ObsoleteGlobalInspection {
            get {
                return ResourceManager.GetString("ObsoleteGlobalInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Assignment uses obsolete &apos;Let&apos; modifier..
        /// </summary>
        public static string ObsoleteLetStatementInspection {
            get {
                return ResourceManager.GetString("ObsoleteLetStatementInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Consider replacing the call to &apos;{0}&apos;. {1}.
        /// </summary>
        public static string ObsoleteMemberUsageInspection {
            get {
                return ResourceManager.GetString("ObsoleteMemberUsageInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} of {1} &apos;{2}&apos; uses an obsolete type hint..
        /// </summary>
        public static string ObsoleteTypeHintInspection {
            get {
                return ResourceManager.GetString("ObsoleteTypeHintInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;While...Wend&apos; conditional loop can be written as a &apos;Do While...Loop&apos; block..
        /// </summary>
        public static string ObsoleteWhileWendStatementInspection {
            get {
                return ResourceManager.GetString("ObsoleteWhileWendStatementInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to On Error GoTo -1 encountered.
        /// </summary>
        public static string OnErrorGoToMinusOneInspection {
            get {
                return ResourceManager.GetString("OnErrorGoToMinusOneInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;On Local Error&apos; statement detected..
        /// </summary>
        public static string OnLocalErrorInspection {
            get {
                return ResourceManager.GetString("OnLocalErrorInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Component &apos;{0}&apos; uses &apos;Option Base 1&apos;..
        /// </summary>
        public static string OptionBaseInspection {
            get {
                return ResourceManager.GetString("OptionBaseInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Component &apos;{0}&apos; uses &apos;Option Base 0&apos;..
        /// </summary>
        public static string OptionBaseZeroInspection {
            get {
                return ResourceManager.GetString("OptionBaseZeroInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;Option Explicit&apos; is not specified in &apos;{0}&apos;..
        /// </summary>
        public static string OptionExplicitInspection {
            get {
                return ResourceManager.GetString("OptionExplicitInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Parameter &apos;{0}&apos; can be passed by value..
        /// </summary>
        public static string ParameterCanBeByValInspection {
            get {
                return ResourceManager.GetString("ParameterCanBeByValInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Parameter &apos;{0}&apos; is not used..
        /// </summary>
        public static string ParameterNotUsedInspection {
            get {
                return ResourceManager.GetString("ParameterNotUsedInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Procedure &apos;{0}&apos; can be written as a function..
        /// </summary>
        public static string ProcedureCanBeWrittenAsFunctionInspection {
            get {
                return ResourceManager.GetString("ProcedureCanBeWrittenAsFunctionInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In a context that requires a procedure, the expression &apos;{0}&apos; of object type &apos;{1}&apos; is used that does not have a suitable default member..
        /// </summary>
        public static string ProcedureRequiredInspection {
            get {
                return ResourceManager.GetString("ProcedureRequiredInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Procedure &apos;{0}&apos; can be written as a function..
        /// </summary>
        public static string ProcedureShouldBeFunctionInspection {
            get {
                return ResourceManager.GetString("ProcedureShouldBeFunctionInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Control &apos;{0}.{1}&apos; is being accessed from outside its parent form..
        /// </summary>
        public static string PublicControlFieldAccessInspection {
            get {
                return ResourceManager.GetString("PublicControlFieldAccessInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The public enumeration &apos;{0}&apos; should be declared within a Standard or Class module.
        /// </summary>
        public static string PublicEnumerationDeclaredInWorksheetInspection {
            get {
                return ResourceManager.GetString("PublicEnumerationDeclaredInWorksheetInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Member &apos;{0}&apos; should be Private.
        /// </summary>
        public static string PublicImplementationShouldBePrivateInspection {
            get {
                return ResourceManager.GetString("PublicImplementationShouldBePrivateInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Attempt to assign Read-Only Property &apos;{0}&apos;.
        /// </summary>
        public static string ReadOnlyPropertyAssignmentInspection {
            get {
                return ResourceManager.GetString("ReadOnlyPropertyAssignmentInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Parameter &apos;{0}&apos; has a redundant &apos;ByRef&apos; modifier..
        /// </summary>
        public static string RedundantByRefModifierInspection {
            get {
                return ResourceManager.GetString("RedundantByRefModifierInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; has no effect..
        /// </summary>
        public static string RedundantOptionInspection {
            get {
                return ResourceManager.GetString("RedundantOptionInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Object reference &apos;{0}&apos; is auto-instantiated..
        /// </summary>
        public static string SelfAssignedDeclarationInspection {
            get {
                return ResourceManager.GetString("SelfAssignedDeclarationInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To the variable &apos;{0}&apos; of declared type &apos;{1}&apos; a value is set assigned with the incompatible declared type &apos;{2}&apos;..
        /// </summary>
        public static string SetAssignmentWithIncompatibleObjectTypeInspection {
            get {
                return ResourceManager.GetString("SetAssignmentWithIncompatibleObjectTypeInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} &apos;{1}&apos; hides {2} &apos;{3}&apos;..
        /// </summary>
        public static string ShadowedDeclarationInspection {
            get {
                return ResourceManager.GetString("ShadowedDeclarationInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Statically accessible sheet can be referred to by its code name..
        /// </summary>
        public static string SheetAccessedUsingStringInspection {
            get {
                return ResourceManager.GetString("SheetAccessedUsingStringInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;Step&apos; not specified..
        /// </summary>
        public static string StepIsNotSpecifiedInspection {
            get {
                return ResourceManager.GetString("StepIsNotSpecifiedInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to 1 is the default step in a &apos;For...Next&apos; loop and therefore is redundant..
        /// </summary>
        public static string StepOneIsRedundantInspection {
            get {
                return ResourceManager.GetString("StepOneIsRedundantInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;Stop&apos; keyword halts execution..
        /// </summary>
        public static string StopKeywordInspection {
            get {
                return ResourceManager.GetString("StopKeywordInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The annotation &apos;{0}&apos; was expected to have less arguments..
        /// </summary>
        public static string SuperfluousAnnotationArgumentInspection {
            get {
                return ResourceManager.GetString("SuperfluousAnnotationArgumentInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to There is an assignment from the default member of the result of expression &apos;{1}&apos; to that of the expression &apos;{0}&apos;..
        /// </summary>
        public static string SuspiciousLetAssignmentInspection {
            get {
                return ResourceManager.GetString("SuspiciousLetAssignmentInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Identifier &apos;{0}&apos; in &apos;{1}&apos; is suspiciously referring to the default instance of that class type..
        /// </summary>
        public static string SuspiciousPredeclaredInstanceAccessInspection {
            get {
                return ResourceManager.GetString("SuspiciousPredeclaredInstanceAccessInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0}
        ///Andrew &quot;ThunderFrame&quot; Jackson would be proud! 
        ///You&apos;re seeing this inspection result because there&apos;s no way that&apos;s real code and you&apos;re just pushing the limits of Rubberduck&apos;s parsing and resolving capabilities, right? ...RIGHT? 
        ///In memoriam, 1972-2018.
        /// </summary>
        public static string ThunderCode_Base {
            get {
                return ResourceManager.GetString("ThunderCode_Base", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Variable &apos;{0}&apos; is used but not assigned..
        /// </summary>
        public static string UnassignedVariableUsageInspection {
            get {
                return ResourceManager.GetString("UnassignedVariableUsageInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Local variable &apos;{0}&apos; is not declared..
        /// </summary>
        public static string UndeclaredVariableInspection {
            get {
                return ResourceManager.GetString("UndeclaredVariableInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Public member name &apos;{0}&apos; contains an underscore..
        /// </summary>
        public static string UnderscoreInPublicClassModuleMemberInspection {
            get {
                return ResourceManager.GetString("UnderscoreInPublicClassModuleMemberInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Errors are ignored but never handled again..
        /// </summary>
        public static string UnhandledOnErrorResumeNextInspection {
            get {
                return ResourceManager.GetString("UnhandledOnErrorResumeNextInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Case clause &apos;{0}&apos; cannot be reached..
        /// </summary>
        public static string UnreachableCaseInspection {
            get {
                return ResourceManager.GetString("UnreachableCaseInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;Case Else&apos; statement is unreachable..
        /// </summary>
        public static string UnreachableCaseInspection_CaseElse {
            get {
                return ResourceManager.GetString("UnreachableCaseInspection_CaseElse", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;Case&apos; statement Range Clauses must be expressed &apos;[x] To [y]&apos; where [x] is less than or equal to [y]&apos;..
        /// </summary>
        public static string UnreachableCaseInspection_InherentlyUnreachable {
            get {
                return ResourceManager.GetString("UnreachableCaseInspection_InherentlyUnreachable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;Case&apos; statement will cause run-time error 6 (Overflow)..
        /// </summary>
        public static string UnreachableCaseInspection_Overflow {
            get {
                return ResourceManager.GetString("UnreachableCaseInspection_Overflow", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;Case&apos; statement will cause run-time error 13 (type mismatch)..
        /// </summary>
        public static string UnreachableCaseInspection_TypeMismatch {
            get {
                return ResourceManager.GetString("UnreachableCaseInspection_TypeMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;Case&apos; statement is unreachable..
        /// </summary>
        public static string UnreachableCaseInspection_Unreachable {
            get {
                return ResourceManager.GetString("UnreachableCaseInspection_Unreachable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; is not a recognized Rubberduck annotation (yet?).
        /// </summary>
        public static string UnrecognizedAnnotationInspection {
            get {
                return ResourceManager.GetString("UnrecognizedAnnotationInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Replace function &apos;{0}&apos; with existing typed function..
        /// </summary>
        public static string UntypedFunctionUsageInspection {
            get {
                return ResourceManager.GetString("UntypedFunctionUsageInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The expression &apos;{0}&apos; uses bang notation..
        /// </summary>
        public static string UseOfBangNotationInspection {
            get {
                return ResourceManager.GetString("UseOfBangNotationInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The expression &apos;{0}&apos; uses a recursive bang operator..
        /// </summary>
        public static string UseOfRecursiveBangNotationInspection {
            get {
                return ResourceManager.GetString("UseOfRecursiveBangNotationInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The expression &apos;{0}&apos; uses an unbound bang operator..
        /// </summary>
        public static string UseOfUnboundBangNotationInspection {
            get {
                return ResourceManager.GetString("UseOfUnboundBangNotationInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In a context that requires a value type, the expression &apos;{0}&apos; of object type &apos;{1}&apos; is used that does not have a suitable default member..
        /// </summary>
        public static string ValueRequiredInspection {
            get {
                return ResourceManager.GetString("ValueRequiredInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Variable &apos;{0}&apos; is not assigned..
        /// </summary>
        public static string VariableNotAssignedInspection {
            get {
                return ResourceManager.GetString("VariableNotAssignedInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} &apos;{1}&apos; is implicitly &apos;Variant&apos;..
        /// </summary>
        public static string VariableTypeNotDeclaredInspection {
            get {
                return ResourceManager.GetString("VariableTypeNotDeclaredInspection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Property &apos;{0}&apos; has no getter..
        /// </summary>
        public static string WriteOnlyPropertyInspection {
            get {
                return ResourceManager.GetString("WriteOnlyPropertyInspection", resourceCulture);
            }
        }
    }
}