//------------------------------------------------------------------------------
// <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 Microsoft.AspNetCore.Razor.Language {
    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", "18.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class Resources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal Resources() {
        }
        
        /// <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("Sandbox.Razor.Microsoft.AspNetCore.Razor.Language.Resources", typeof(Resources).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 Register Tag Helpers for use in the current document..
        /// </summary>
        internal static string AddTagHelperDirective_Description {
            get {
                return ResourceManager.GetString("AddTagHelperDirective_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Add tag helpers from the specified type name and assembly name. Specify &apos;*&apos; for the type name to include all tag helper types from the specified assembly..
        /// </summary>
        internal static string AddTagHelperDirective_StringToken_Description {
            get {
                return ResourceManager.GetString("AddTagHelperDirective_StringToken_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to TypeName, AssemblyName.
        /// </summary>
        internal static string AddTagHelperDirective_StringToken_Name {
            get {
                return ResourceManager.GetString("AddTagHelperDirective_StringToken_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Value cannot be null or an empty string..
        /// </summary>
        internal static string ArgumentCannotBeNullOrEmpty {
            get {
                return ResourceManager.GetString("ArgumentCannotBeNullOrEmpty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Block cannot be built because a Type has not been specified in the BlockBuilder.
        /// </summary>
        internal static string Block_Type_Not_Specified {
            get {
                return ResourceManager.GetString("Block_Type_Not_Specified", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Block directive &apos;{0}&apos; cannot be imported..
        /// </summary>
        internal static string BlockDirectiveCannotBeImported {
            get {
                return ResourceManager.GetString("BlockDirectiveCannotBeImported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to code.
        /// </summary>
        internal static string BlockName_Code {
            get {
                return ResourceManager.GetString("BlockName_Code", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to explicit expression.
        /// </summary>
        internal static string BlockName_ExplicitExpression {
            get {
                return ResourceManager.GetString("BlockName_ExplicitExpression", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid newline sequence &apos;{0}&apos;. Support newline sequences are &apos;\r\n&apos; and &apos;\n&apos;..
        /// </summary>
        internal static string CodeWriter_InvalidNewLine {
            get {
                return ResourceManager.GetString("CodeWriter_InvalidNewLine", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Component &apos;{0}&apos; expects a value for the parameter &apos;{1}&apos;, but a value may not have been provided..
        /// </summary>
        internal static string Component_EditorRequiredParameterNotSpecified {
            get {
                return ResourceManager.GetString("Component_EditorRequiredParameterNotSpecified", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;character literal&gt;&gt;.
        /// </summary>
        internal static string CSharpToken_CharacterLiteral {
            get {
                return ResourceManager.GetString("CSharpToken_CharacterLiteral", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;comment&gt;&gt;.
        /// </summary>
        internal static string CSharpToken_Comment {
            get {
                return ResourceManager.GetString("CSharpToken_Comment", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;identifier&gt;&gt;.
        /// </summary>
        internal static string CSharpToken_Identifier {
            get {
                return ResourceManager.GetString("CSharpToken_Identifier", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;integer literal&gt;&gt;.
        /// </summary>
        internal static string CSharpToken_IntegerLiteral {
            get {
                return ResourceManager.GetString("CSharpToken_IntegerLiteral", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;keyword&gt;&gt;.
        /// </summary>
        internal static string CSharpToken_Keyword {
            get {
                return ResourceManager.GetString("CSharpToken_Keyword", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;newline sequence&gt;&gt;.
        /// </summary>
        internal static string CSharpToken_Newline {
            get {
                return ResourceManager.GetString("CSharpToken_Newline", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;real literal&gt;&gt;.
        /// </summary>
        internal static string CSharpToken_RealLiteral {
            get {
                return ResourceManager.GetString("CSharpToken_RealLiteral", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;string literal&gt;&gt;.
        /// </summary>
        internal static string CSharpToken_StringLiteral {
            get {
                return ResourceManager.GetString("CSharpToken_StringLiteral", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;white space&gt;&gt;.
        /// </summary>
        internal static string CSharpToken_Whitespace {
            get {
                return ResourceManager.GetString("CSharpToken_Whitespace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to @import rules are not supported within scoped CSS files because the loading order would be undefined. @import may only be placed in non-scoped CSS files..
        /// </summary>
        internal static string CssRewriter_ImportNotAllowed {
            get {
                return ResourceManager.GetString("CssRewriter_ImportNotAllowed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The document type &apos;{0}&apos; does not support the extension &apos;{1}&apos;..
        /// </summary>
        internal static string Diagnostic_CodeTarget_UnsupportedExtension {
            get {
                return ResourceManager.GetString("Diagnostic_CodeTarget_UnsupportedExtension", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid directive keyword &apos;{0}&apos;. Directives must have a non-empty keyword that consists only of letters..
        /// </summary>
        internal static string DirectiveDescriptor_InvalidDirectiveKeyword {
            get {
                return ResourceManager.GetString("DirectiveDescriptor_InvalidDirectiveKeyword", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A non-optional directive token cannot follow an optional directive token..
        /// </summary>
        internal static string DirectiveDescriptor_InvalidNonOptionalToken {
            get {
                return ResourceManager.GetString("DirectiveDescriptor_InvalidNonOptionalToken", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; directive expects a boolean literal..
        /// </summary>
        internal static string DirectiveExpectsBooleanLiteral {
            get {
                return ResourceManager.GetString("DirectiveExpectsBooleanLiteral", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; directive expects a C# attribute..
        /// </summary>
        internal static string DirectiveExpectsCSharpAttribute {
            get {
                return ResourceManager.GetString("DirectiveExpectsCSharpAttribute", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; directive expects an identifier..
        /// </summary>
        internal static string DirectiveExpectsIdentifier {
            get {
                return ResourceManager.GetString("DirectiveExpectsIdentifier", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; directive expects a namespace name..
        /// </summary>
        internal static string DirectiveExpectsNamespace {
            get {
                return ResourceManager.GetString("DirectiveExpectsNamespace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; directive expects a string surrounded by double quotes..
        /// </summary>
        internal static string DirectiveExpectsQuotedStringLiteral {
            get {
                return ResourceManager.GetString("DirectiveExpectsQuotedStringLiteral", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; directive expects a type name..
        /// </summary>
        internal static string DirectiveExpectsTypeName {
            get {
                return ResourceManager.GetString("DirectiveExpectsTypeName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type parameter in the generic type constraint &apos;{1}&apos; does not match the type parameter &apos;{2}&apos; defined in the directive &apos;{0}&apos;..
        /// </summary>
        internal static string DirectiveGenericTypeParameterIdentifierMismatch {
            get {
                return ResourceManager.GetString("DirectiveGenericTypeParameterIdentifierMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}` directive must appear at the start of the line..
        /// </summary>
        internal static string DirectiveMustAppearAtStartOfLine {
            get {
                return ResourceManager.GetString("DirectiveMustAppearAtStartOfLine", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; directives value(s) must be separated by whitespace..
        /// </summary>
        internal static string DirectiveTokensMustBeSeparatedByWhitespace {
            get {
                return ResourceManager.GetString("DirectiveTokensMustBeSeparatedByWhitespace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The document of kind &apos;{0}&apos; does not have a &apos;{1}&apos;. The document classifier must set a value for &apos;{2}&apos;..
        /// </summary>
        internal static string DocumentMissingTarget {
            get {
                return ResourceManager.GetString("DocumentMissingTarget", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; directive may only occur once per document..
        /// </summary>
        internal static string DuplicateDirective {
            get {
                return ResourceManager.GetString("DuplicateDirective", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &quot;EndBlock&quot; was called without a matching call to &quot;StartBlock&quot;..
        /// </summary>
        internal static string EndBlock_Called_Without_Matching_StartBlock {
            get {
                return ResourceManager.GetString("EndBlock_Called_Without_Matching_StartBlock", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to line break.
        /// </summary>
        internal static string ErrorComponent_Newline {
            get {
                return ResourceManager.GetString("ErrorComponent_Newline", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; feature requires a &apos;{1}&apos; provided by the &apos;{2}&apos;..
        /// </summary>
        internal static string FeatureDependencyMissing {
            get {
                return ResourceManager.GetString("FeatureDependencyMissing", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The feature must be initialized by setting the &apos;{0}&apos; property..
        /// </summary>
        internal static string FeatureMustBeInitialized {
            get {
                return ResourceManager.GetString("FeatureMustBeInitialized", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specify a C# code block..
        /// </summary>
        internal static string FunctionsDirective_Description {
            get {
                return ResourceManager.GetString("FunctionsDirective_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;newline sequence&gt;&gt;.
        /// </summary>
        internal static string HtmlToken_NewLine {
            get {
                return ResourceManager.GetString("HtmlToken_NewLine", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;razor comment&gt;&gt;.
        /// </summary>
        internal static string HtmlToken_RazorComment {
            get {
                return ResourceManager.GetString("HtmlToken_RazorComment", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;text&gt;&gt;.
        /// </summary>
        internal static string HtmlToken_Text {
            get {
                return ResourceManager.GetString("HtmlToken_Text", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;white space&gt;&gt;.
        /// </summary>
        internal static string HtmlToken_WhiteSpace {
            get {
                return ResourceManager.GetString("HtmlToken_WhiteSpace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specify the base class for the current document..
        /// </summary>
        internal static string InheritsDirective_Description {
            get {
                return ResourceManager.GetString("InheritsDirective_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The base type that the current page inherits..
        /// </summary>
        internal static string InheritsDirective_TypeToken_Description {
            get {
                return ResourceManager.GetString("InheritsDirective_TypeToken_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to TypeName.
        /// </summary>
        internal static string InheritsDirective_TypeToken_Name {
            get {
                return ResourceManager.GetString("InheritsDirective_TypeToken_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; operation is not valid when the builder is empty..
        /// </summary>
        internal static string IntermediateNodeBuilder_PopInvalid {
            get {
                return ResourceManager.GetString("IntermediateNodeBuilder_PopInvalid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The node &apos;{0}&apos; has a read-only child collection and cannot be modified..
        /// </summary>
        internal static string IntermediateNodeReference_CollectionIsReadOnly {
            get {
                return ResourceManager.GetString("IntermediateNodeReference_CollectionIsReadOnly", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The reference is invalid. The node &apos;{0}&apos; could not be found as a child of &apos;{1}&apos;..
        /// </summary>
        internal static string IntermediateNodeReference_NodeNotFound {
            get {
                return ResourceManager.GetString("IntermediateNodeReference_NodeNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The reference is invalid. References initialized with the default constructor cannot modify nodes..
        /// </summary>
        internal static string IntermediateNodeReference_NotInitialized {
            get {
                return ResourceManager.GetString("IntermediateNodeReference_NotInitialized", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; node type can only be used as a direct child of a &apos;{1}&apos; node..
        /// </summary>
        internal static string IntermediateNodes_InvalidParentNode {
            get {
                return ResourceManager.GetString("IntermediateNodes_InvalidParentNode", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The node &apos;{0}&apos; is not the owner of change &apos;{1}&apos;..
        /// </summary>
        internal static string InvalidOperation_SpanIsNotChangeOwner {
            get {
                return ResourceManager.GetString("InvalidOperation_SpanIsNotChangeOwner", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid tag helper directive look up text &apos;{0}&apos;. The correct look up text format is: &quot;name, assemblyName&quot;..
        /// </summary>
        internal static string InvalidTagHelperLookupText {
            get {
                return ResourceManager.GetString("InvalidTagHelperLookupText", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid tag helper directive &apos;{0}&apos; value. &apos;{1}&apos; is not allowed in prefix &apos;{2}&apos;..
        /// </summary>
        internal static string InvalidTagHelperPrefixValue {
            get {
                return ResourceManager.GetString("InvalidTagHelperPrefixValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The key must not be null..
        /// </summary>
        internal static string KeyMustNotBeNull {
            get {
                return ResourceManager.GetString("KeyMustNotBeNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot use built-in RazorComment handler, language characteristics does not define the CommentStart, CommentStar and CommentBody known token types or parser does not override TokenizerBackedParser.OutputSpanBeforeRazorComment.
        /// </summary>
        internal static string Language_Does_Not_Support_RazorComment {
            get {
                return ResourceManager.GetString("Language_Does_Not_Support_RazorComment", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The specified encoding &apos;{0}&apos; does not match the content&apos;s encoding &apos;{1}&apos;..
        /// </summary>
        internal static string MismatchedContentEncoding {
            get {
                return ResourceManager.GetString("MismatchedContentEncoding", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specify the base namespace for the document..
        /// </summary>
        internal static string NamespaceDirective_Description {
            get {
                return ResourceManager.GetString("NamespaceDirective_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The namespace for the document..
        /// </summary>
        internal static string NamespaceDirective_NamespaceToken_Description {
            get {
                return ResourceManager.GetString("NamespaceDirective_NamespaceToken_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Namespace.
        /// </summary>
        internal static string NamespaceDirective_NamespaceToken_Name {
            get {
                return ResourceManager.GetString("NamespaceDirective_NamespaceToken_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &quot;@&quot; character must be followed by a &quot;:&quot;, &quot;(&quot;, or a C# identifier.  If you intended to switch to markup, use an HTML start tag, for example:
        ///
        ///@if(isLoggedIn) {{
        ///    &lt;p&gt;Hello, @user!&lt;/p&gt;
        ///}}.
        /// </summary>
        internal static string ParseError_AtInCode_Must_Be_Followed_By_Colon_Paren_Or_Identifier_Start {
            get {
                return ResourceManager.GetString("ParseError_AtInCode_Must_Be_Followed_By_Colon_Paren_Or_Identifier_Start", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to End of file was reached before the end of the block comment.  All comments started with &quot;/*&quot; sequence must be terminated with a matching &quot;*/&quot; sequence..
        /// </summary>
        internal static string ParseError_BlockComment_Not_Terminated {
            get {
                return ResourceManager.GetString("ParseError_BlockComment_Not_Terminated", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Directive &apos;{0}&apos; must have a value..
        /// </summary>
        internal static string ParseError_DirectiveMustHaveValue {
            get {
                return ResourceManager.GetString("ParseError_DirectiveMustHaveValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An opening &quot;{0}&quot; is missing the corresponding closing &quot;{1}&quot;..
        /// </summary>
        internal static string ParseError_Expected_CloseBracket_Before_EOF {
            get {
                return ResourceManager.GetString("ParseError_Expected_CloseBracket_Before_EOF", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0} block is missing a closing &quot;{1}&quot; character.  Make sure you have a matching &quot;{1}&quot; character for all the &quot;{2}&quot; characters within this block, and that none of the &quot;{1}&quot; characters are being interpreted as markup..
        /// </summary>
        internal static string ParseError_Expected_EndOfBlock_Before_EOF {
            get {
                return ResourceManager.GetString("ParseError_Expected_EndOfBlock_Before_EOF", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0} directive is not supported..
        /// </summary>
        internal static string ParseError_HelperDirectiveNotAvailable {
            get {
                return ResourceManager.GetString("ParseError_HelperDirectiveNotAvailable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Optional quote around the directive &apos;{0}&apos; is missing the corresponding opening or closing quote..
        /// </summary>
        internal static string ParseError_IncompleteQuotesAroundDirective {
            get {
                return ResourceManager.GetString("ParseError_IncompleteQuotesAroundDirective", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Inline markup blocks (@&lt;p&gt;Content&lt;/p&gt;) cannot be nested.  Only one level of inline markup is allowed..
        /// </summary>
        internal static string ParseError_InlineMarkup_Blocks_Cannot_Be_Nested {
            get {
                return ResourceManager.GetString("ParseError_InlineMarkup_Blocks_Cannot_Be_Nested", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Markup in a code block must start with a tag and all start tags must be matched with end tags.  Do not use unclosed tags like &quot;&lt;br&gt;&quot;.  Instead use self-closing tags like &quot;&lt;br/&gt;&quot;..
        /// </summary>
        internal static string ParseError_MarkupBlock_Must_Start_With_Tag {
            get {
                return ResourceManager.GetString("ParseError_MarkupBlock_Must_Start_With_Tag", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &quot;{0}&quot; element was not closed.  All elements must be either self-closing or have a matching end tag..
        /// </summary>
        internal static string ParseError_MissingEndTag {
            get {
                return ResourceManager.GetString("ParseError_MissingEndTag", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Namespace imports and type aliases cannot be placed within code blocks.  They must immediately follow an &quot;@&quot; character in markup.  It is recommended that you put them at the top of the page, as in the following example:
        ///
        ///@using System.Drawing;
        ///@{{
        ///    // OK here to use types from System.Drawing in the page.
        ///}}.
        /// </summary>
        internal static string ParseError_NamespaceImportAndTypeAlias_Cannot_Exist_Within_CodeBlock {
            get {
                return ResourceManager.GetString("ParseError_NamespaceImportAndTypeAlias_Cannot_Exist_Within_CodeBlock", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Outer tag is missing a name. The first character of a markup block must be an HTML tag with a valid name..
        /// </summary>
        internal static string ParseError_OuterTagMissingName {
            get {
                return ResourceManager.GetString("ParseError_OuterTagMissingName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to End of file was reached before the end of the block comment.  All comments that start with the &quot;@*&quot; sequence must be terminated with a matching &quot;*@&quot; sequence..
        /// </summary>
        internal static string ParseError_RazorComment_Not_Terminated {
            get {
                return ResourceManager.GetString("ParseError_RazorComment_Not_Terminated", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &quot;{0}&quot; is a reserved word and cannot be used in implicit expressions.  An explicit expression (&quot;@()&quot;) must be used..
        /// </summary>
        internal static string ParseError_ReservedWord {
            get {
                return ResourceManager.GetString("ParseError_ReservedWord", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Section blocks (&quot;{0}&quot;) cannot be nested.  Only one level of section blocks are allowed..
        /// </summary>
        internal static string ParseError_Sections_Cannot_Be_Nested {
            get {
                return ResourceManager.GetString("ParseError_Sections_Cannot_Be_Nested", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Single-statement control-flow statements in Razor documents statements cannot contain markup. Markup should be enclosed in &quot;{{&quot; and &quot;}}&quot;..
        /// </summary>
        internal static string ParseError_SingleLine_ControlFlowStatements_CannotContainMarkup {
            get {
                return ResourceManager.GetString("ParseError_SingleLine_ControlFlowStatements_CannotContainMarkup", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &quot;&lt;text&gt;&quot; and &quot;&lt;/text&gt;&quot; tags cannot contain attributes..
        /// </summary>
        internal static string ParseError_TextTagCannotContainAttributes {
            get {
                return ResourceManager.GetString("ParseError_TextTagCannotContainAttributes", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &quot;{0}&quot; is not valid at the start of a code block.  Only identifiers, keywords, comments, &quot;(&quot; and &quot;{{&quot; are valid..
        /// </summary>
        internal static string ParseError_Unexpected_Character_At_Start_Of_CodeBlock {
            get {
                return ResourceManager.GetString("ParseError_Unexpected_Character_At_Start_Of_CodeBlock", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to End-of-file was found after the &quot;@&quot; character.  &quot;@&quot; must be followed by a valid code block.  If you want to output an &quot;@&quot;, escape it using the sequence: &quot;@@&quot;.
        /// </summary>
        internal static string ParseError_Unexpected_EndOfFile_At_Start_Of_CodeBlock {
            get {
                return ResourceManager.GetString("ParseError_Unexpected_EndOfFile_At_Start_Of_CodeBlock", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; is not valid in this position. Valid options are &apos;{1}&apos;.
        /// </summary>
        internal static string ParseError_Unexpected_Identifier_At_Position {
            get {
                return ResourceManager.GetString("ParseError_Unexpected_Identifier_At_Position", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unexpected &quot;{{&quot; after &quot;@&quot; character. Once inside the body of a code block (@if {{}}, @{{}}, etc.) you do not need to use &quot;@{{&quot; to switch to code..
        /// </summary>
        internal static string ParseError_Unexpected_Nested_CodeBlock {
            get {
                return ResourceManager.GetString("ParseError_Unexpected_Nested_CodeBlock", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A space or line break was encountered after the &quot;@&quot; character.  Only valid identifiers, keywords, comments, &quot;(&quot; and &quot;{{&quot; are valid at the start of a code block and they must occur immediately following &quot;@&quot; with no space in between..
        /// </summary>
        internal static string ParseError_Unexpected_WhiteSpace_At_Start_Of_CodeBlock {
            get {
                return ResourceManager.GetString("ParseError_Unexpected_WhiteSpace_At_Start_Of_CodeBlock", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Encountered end tag &quot;{0}&quot; with no matching start tag.  Are your start/end tags properly balanced?.
        /// </summary>
        internal static string ParseError_UnexpectedEndTag {
            get {
                return ResourceManager.GetString("ParseError_UnexpectedEndTag", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to End of file or an unexpected character was reached before the &quot;{0}&quot; tag could be parsed.  Elements inside markup blocks must be complete. They must either be self-closing (&quot;&lt;br /&gt;&quot;) or have matching end tags (&quot;&lt;p&gt;Hello&lt;/p&gt;&quot;).  If you intended to display a &quot;&lt;&quot; character, use the &quot;&amp;lt;&quot; HTML entity..
        /// </summary>
        internal static string ParseError_UnfinishedTag {
            get {
                return ResourceManager.GetString("ParseError_UnfinishedTag", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unterminated string literal.  Strings that start with a quotation mark (&quot;) must be terminated before the end of the line.  However, strings that start with @ and a quotation mark (@&quot;) can span multiple lines..
        /// </summary>
        internal static string ParseError_Unterminated_String_Literal {
            get {
                return ResourceManager.GetString("ParseError_Unterminated_String_Literal", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Parser was started with a null Context property.  The Context property must be set BEFORE calling any methods on the parser..
        /// </summary>
        internal static string Parser_Context_Not_Set {
            get {
                return ResourceManager.GetString("Parser_Context_Not_Set", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot complete the tree, StartBlock must be called at least once..
        /// </summary>
        internal static string ParserContext_CannotCompleteTree_NoRootBlock {
            get {
                return ResourceManager.GetString("ParserContext_CannotCompleteTree_NoRootBlock", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot complete the tree, there are still open blocks..
        /// </summary>
        internal static string ParserContext_CannotCompleteTree_OutstandingBlocks {
            get {
                return ResourceManager.GetString("ParserContext_CannotCompleteTree_OutstandingBlocks", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot finish span, there is no current block. Call StartBlock at least once before finishing a span.
        /// </summary>
        internal static string ParserContext_NoCurrentBlock {
            get {
                return ResourceManager.GetString("ParserContext_NoCurrentBlock", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; phase requires a &apos;{1}&apos; provided by the &apos;{2}&apos;..
        /// </summary>
        internal static string PhaseDependencyMissing {
            get {
                return ResourceManager.GetString("PhaseDependencyMissing", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The phase must be initialized by setting the &apos;{0}&apos; property..
        /// </summary>
        internal static string PhaseMustBeInitialized {
            get {
                return ResourceManager.GetString("PhaseMustBeInitialized", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}.{1}&apos; property must not be null..
        /// </summary>
        internal static string PropertyMustNotBeNull {
            get {
                return ResourceManager.GetString("PropertyMustNotBeNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The Razor language version &apos;{0}&apos; is unrecognized or not supported by this version of Razor..
        /// </summary>
        internal static string RazorLanguageVersion_InvalidVersion {
            get {
                return ResourceManager.GetString("RazorLanguageVersion_InvalidVersion", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Path must begin with a forward slash &apos;/&apos;..
        /// </summary>
        internal static string RazorProject_PathMustStartWithForwardSlash {
            get {
                return ResourceManager.GetString("RazorProject_PathMustStartWithForwardSlash", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; is missing feature &apos;{1}&apos;..
        /// </summary>
        internal static string RazorProjectEngineMissingFeatureDependency {
            get {
                return ResourceManager.GetString("RazorProjectEngineMissingFeatureDependency", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Remove Tag Helpers for use in the current document..
        /// </summary>
        internal static string RemoveTagHelperDirective_Description {
            get {
                return ResourceManager.GetString("RemoveTagHelperDirective_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Remove tag helpers from the specified type name and assembly name. Specify &apos;*&apos; for the type name to remove all tag helper types from the specified assembly..
        /// </summary>
        internal static string RemoveTagHelperDirective_StringToken_Description {
            get {
                return ResourceManager.GetString("RemoveTagHelperDirective_StringToken_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to TypeName, AssemblyName.
        /// </summary>
        internal static string RemoveTagHelperDirective_StringToken_Name {
            get {
                return ResourceManager.GetString("RemoveTagHelperDirective_StringToken_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; requires a &apos;{1}&apos; delegate to be set..
        /// </summary>
        internal static string RenderingContextRequiresDelegate {
            get {
                return ResourceManager.GetString("RenderingContextRequiresDelegate", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Not enough stack space to continue parsing this document. Razor doesn&apos;t support deeply nested elements..
        /// </summary>
        internal static string Rewriter_InsufficientStack {
            get {
                return ResourceManager.GetString("Rewriter_InsufficientStack", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Attribute &apos;{0}&apos; on tag helper element &apos;{1}&apos; requires a value. Tag helper bound attributes of type &apos;{2}&apos; cannot be empty or contain only whitespace..
        /// </summary>
        internal static string RewriterError_EmptyTagHelperBoundAttribute {
            get {
                return ResourceManager.GetString("RewriterError_EmptyTagHelperBoundAttribute", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Define a section to be rendered in the configured layout page..
        /// </summary>
        internal static string SectionDirective_Description {
            get {
                return ResourceManager.GetString("SectionDirective_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the section..
        /// </summary>
        internal static string SectionDirective_NameToken_Description {
            get {
                return ResourceManager.GetString("SectionDirective_NameToken_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to SectionName.
        /// </summary>
        internal static string SectionDirective_NameToken_Name {
            get {
                return ResourceManager.GetString("SectionDirective_NameToken_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to @section Header { ... }.
        /// </summary>
        internal static string SectionExample {
            get {
                return ResourceManager.GetString("SectionExample", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid tag helper bound property &apos;{1}&apos; on tag helper &apos;{0}&apos;. Tag helpers cannot bind to HTML attributes with name &apos;{2}&apos; because the name contains a &apos;{3}&apos; character..
        /// </summary>
        internal static string TagHelper_InvalidBoundAttributeName {
            get {
                return ResourceManager.GetString("TagHelper_InvalidBoundAttributeName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid tag helper bound property &apos;{1}&apos; on tag helper &apos;{0}&apos;. Tag helpers cannot bind to HTML attributes with name &apos;{2}&apos; because the name starts with &apos;{3}&apos;..
        /// </summary>
        internal static string TagHelper_InvalidBoundAttributeNameStartsWith {
            get {
                return ResourceManager.GetString("TagHelper_InvalidBoundAttributeNameStartsWith", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid tag helper bound property &apos;{1}&apos; on tag helper &apos;{0}&apos;. Tag helpers cannot bind to HTML attributes with a null or empty name..
        /// </summary>
        internal static string TagHelper_InvalidBoundAttributeNullOrWhitespace {
            get {
                return ResourceManager.GetString("TagHelper_InvalidBoundAttributeNullOrWhitespace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid tag helper bound attribute parameter &apos;{1}&apos; on bound attribute &apos;{0}&apos;. Tag helpers cannot bind to HTML attribute parameters with name &apos;{1}&apos; because the name contains a &apos;{3}&apos; character..
        /// </summary>
        internal static string TagHelper_InvalidBoundAttributeParameterName {
            get {
                return ResourceManager.GetString("TagHelper_InvalidBoundAttributeParameterName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid tag helper bound attribute parameter &apos;{0}&apos;. Tag helpers cannot bind to HTML attribute parameters with a null or empty name..
        /// </summary>
        internal static string TagHelper_InvalidBoundAttributeParameterNullOrWhitespace {
            get {
                return ResourceManager.GetString("TagHelper_InvalidBoundAttributeParameterNullOrWhitespace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid tag helper bound property &apos;{1}&apos; on tag helper &apos;{0}&apos;. Tag helpers cannot bind to HTML attributes with prefix &apos;{2}&apos; because the prefix contains a &apos;{3}&apos; character..
        /// </summary>
        internal static string TagHelper_InvalidBoundAttributePrefix {
            get {
                return ResourceManager.GetString("TagHelper_InvalidBoundAttributePrefix", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid tag helper bound property &apos;{1}&apos; on tag helper &apos;{0}&apos;. Tag helpers cannot bind to HTML attributes with prefix &apos;{2}&apos; because the prefix starts with &apos;{3}&apos;..
        /// </summary>
        internal static string TagHelper_InvalidBoundAttributePrefixStartsWith {
            get {
                return ResourceManager.GetString("TagHelper_InvalidBoundAttributePrefixStartsWith", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid tag helper bound directive attribute &apos;{1}&apos; on tag helper &apos;{0}&apos;. The directive attribute &apos;{2}&apos; should start with a &apos;@&apos; character..
        /// </summary>
        internal static string TagHelper_InvalidBoundDirectiveAttributeName {
            get {
                return ResourceManager.GetString("TagHelper_InvalidBoundDirectiveAttributeName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid tag helper bound directive attribute &apos;{1}&apos; on tag helper &apos;{0}&apos;. Tag helpers cannot bind to directive attributes with prefix &apos;{2}&apos; because the prefix doesn&apos;t start with a &apos;@&apos; character..
        /// </summary>
        internal static string TagHelper_InvalidBoundDirectiveAttributePrefix {
            get {
                return ResourceManager.GetString("TagHelper_InvalidBoundDirectiveAttributePrefix", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid tag helper required directive attribute &apos;{0}&apos;. The directive attribute &apos;{1}&apos; should start with a &apos;@&apos; character..
        /// </summary>
        internal static string TagHelper_InvalidRequiredDirectiveAttributeName {
            get {
                return ResourceManager.GetString("TagHelper_InvalidRequiredDirectiveAttributeName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid restricted child &apos;{1}&apos; for tag helper &apos;{0}&apos;. Tag helpers cannot restrict child elements that contain a &apos;{2}&apos; character..
        /// </summary>
        internal static string TagHelper_InvalidRestrictedChild {
            get {
                return ResourceManager.GetString("TagHelper_InvalidRestrictedChild", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid restricted child for tag helper &apos;{0}&apos;. Name cannot be null or whitespace..
        /// </summary>
        internal static string TagHelper_InvalidRestrictedChildNullOrWhitespace {
            get {
                return ResourceManager.GetString("TagHelper_InvalidRestrictedChildNullOrWhitespace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tag helpers cannot target attribute name &apos;{0}&apos; because it contains a &apos;{1}&apos; character..
        /// </summary>
        internal static string TagHelper_InvalidTargetedAttributeName {
            get {
                return ResourceManager.GetString("TagHelper_InvalidTargetedAttributeName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Targeted attribute name cannot be null or whitespace..
        /// </summary>
        internal static string TagHelper_InvalidTargetedAttributeNameNullOrWhitespace {
            get {
                return ResourceManager.GetString("TagHelper_InvalidTargetedAttributeNameNullOrWhitespace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tag helpers cannot target parent tag name &apos;{0}&apos; because it contains a &apos;{1}&apos; character..
        /// </summary>
        internal static string TagHelper_InvalidTargetedParentTagName {
            get {
                return ResourceManager.GetString("TagHelper_InvalidTargetedParentTagName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Targeted parent tag name cannot be null or whitespace..
        /// </summary>
        internal static string TagHelper_InvalidTargetedParentTagNameNullOrWhitespace {
            get {
                return ResourceManager.GetString("TagHelper_InvalidTargetedParentTagNameNullOrWhitespace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tag helpers cannot target tag name &apos;{0}&apos; because it contains a &apos;{1}&apos; character..
        /// </summary>
        internal static string TagHelper_InvalidTargetedTagName {
            get {
                return ResourceManager.GetString("TagHelper_InvalidTargetedTagName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Targeted tag name cannot be null or whitespace..
        /// </summary>
        internal static string TagHelper_InvalidTargetedTagNameNullOrWhitespace {
            get {
                return ResourceManager.GetString("TagHelper_InvalidTargetedTagNameNullOrWhitespace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tag helper directive assembly name cannot be null or empty..
        /// </summary>
        internal static string TagHelperAssemblyNameCannotBeEmptyOrNull {
            get {
                return ResourceManager.GetString("TagHelperAssemblyNameCannotBeEmptyOrNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The tag helper attribute &apos;{0}&apos; in element &apos;{1}&apos; is missing a key. The syntax is &apos;&lt;{1} {0}{{ key }}=&quot;value&quot;&gt;&apos;..
        /// </summary>
        internal static string TagHelperBlockRewriter_IndexerAttributeNameMustIncludeKey {
            get {
                return ResourceManager.GetString("TagHelperBlockRewriter_IndexerAttributeNameMustIncludeKey", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to TagHelper attributes must be well-formed..
        /// </summary>
        internal static string TagHelperBlockRewriter_TagHelperAttributeListMustBeWellFormed {
            get {
                return ResourceManager.GetString("TagHelperBlockRewriter_TagHelperAttributeListMustBeWellFormed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The parent &lt;{0}&gt; tag helper does not allow non-tag content. Only child tag helper(s) targeting tag name(s) &apos;{1}&apos; are allowed..
        /// </summary>
        internal static string TagHelperParseTreeRewriter_CannotHaveNonTagContent {
            get {
                return ResourceManager.GetString("TagHelperParseTreeRewriter_CannotHaveNonTagContent", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Found an end tag (&lt;/{0}&gt;) for tag helper &apos;{1}&apos; with tag structure that disallows an end tag (&apos;{2}&apos;)..
        /// </summary>
        internal static string TagHelperParseTreeRewriter_EndTagTagHelperMustNotHaveAnEndTag {
            get {
                return ResourceManager.GetString("TagHelperParseTreeRewriter_EndTagTagHelperMustNotHaveAnEndTag", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tag helpers &apos;{0}&apos; and &apos;{1}&apos; targeting element &apos;{2}&apos; must not expect different {3} values..
        /// </summary>
        internal static string TagHelperParseTreeRewriter_InconsistentTagStructure {
            get {
                return ResourceManager.GetString("TagHelperParseTreeRewriter_InconsistentTagStructure", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;{0}&gt; tag is not allowed by parent &lt;{1}&gt; tag helper. Only child tags with name(s) &apos;{2}&apos; are allowed..
        /// </summary>
        internal static string TagHelperParseTreeRewriter_InvalidNestedTag {
            get {
                return ResourceManager.GetString("TagHelperParseTreeRewriter_InvalidNestedTag", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specify a prefix that is required in an element name for it to be included in Tag Helper processing..
        /// </summary>
        internal static string TagHelperPrefixDirective_Description {
            get {
                return ResourceManager.GetString("TagHelperPrefixDirective_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The tag prefix to apply to tag helpers..
        /// </summary>
        internal static string TagHelperPrefixDirective_PrefixToken_Description {
            get {
                return ResourceManager.GetString("TagHelperPrefixDirective_PrefixToken_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Prefix.
        /// </summary>
        internal static string TagHelperPrefixDirective_PrefixToken_Name {
            get {
                return ResourceManager.GetString("TagHelperPrefixDirective_PrefixToken_Name", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tag Helper &apos;{0}&apos;s attributes must have names..
        /// </summary>
        internal static string TagHelpers_AttributesMustHaveAName {
            get {
                return ResourceManager.GetString("TagHelpers_AttributesMustHaveAName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The tag helper &apos;{0}&apos; must not have C# in the element&apos;s attribute declaration area..
        /// </summary>
        internal static string TagHelpers_CannotHaveCSharpInTagDeclaration {
            get {
                return ResourceManager.GetString("TagHelpers_CannotHaveCSharpInTagDeclaration", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Code blocks (e.g. @{{var variable = 23;}}) must not appear in non-string tag helper attribute values.
        /// Already in an expression (code) context. If necessary an explicit expression (e.g. @(@readonly)) may be used..
        /// </summary>
        internal static string TagHelpers_CodeBlocks_NotSupported_InAttributes {
            get {
                return ResourceManager.GetString("TagHelpers_CodeBlocks_NotSupported_InAttributes", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Inline markup blocks (e.g. @&lt;p&gt;content&lt;/p&gt;) must not appear in non-string tag helper attribute values.
        /// Expected a &apos;{0}&apos; attribute value, not a string..
        /// </summary>
        internal static string TagHelpers_InlineMarkupBlocks_NotSupported_InAttributes {
            get {
                return ResourceManager.GetString("TagHelpers_InlineMarkupBlocks_NotSupported_InAttributes", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Found a malformed &apos;{0}&apos; tag helper. Tag helpers must have a start and end tag or be self closing..
        /// </summary>
        internal static string TagHelpersParseTreeRewriter_FoundMalformedTagHelper {
            get {
                return ResourceManager.GetString("TagHelpersParseTreeRewriter_FoundMalformedTagHelper", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Missing close angle for tag helper &apos;{0}&apos;..
        /// </summary>
        internal static string TagHelpersParseTreeRewriter_MissingCloseAngle {
            get {
                return ResourceManager.GetString("TagHelpersParseTreeRewriter_MissingCloseAngle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;unknown&gt;&gt;.
        /// </summary>
        internal static string Token_Unknown {
            get {
                return ResourceManager.GetString("Token_Unknown", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unreachable code. This can happen when a new {0} is introduced..
        /// </summary>
        internal static string UnexpectedDirectiveKind {
            get {
                return ResourceManager.GetString("UnexpectedDirectiveKind", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unexpected literal following the &apos;{0}&apos; directive. Expected &apos;{1}&apos;..
        /// </summary>
        internal static string UnexpectedDirectiveLiteral {
            get {
                return ResourceManager.GetString("UnexpectedDirectiveLiteral", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unexpected end of file following the &apos;{0}&apos; directive. Expected &apos;{1}&apos;..
        /// </summary>
        internal static string UnexpectedEOFAfterDirective {
            get {
                return ResourceManager.GetString("UnexpectedEOFAfterDirective", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The hash algorithm &apos;{0}&apos; is not supported for checksum generation. Supported algorithms are: &apos;{1}&apos;. Set &apos;{2}&apos; to &apos;{3}&apos; to suppress automatic checksum generation..
        /// </summary>
        internal static string UnsupportedChecksumAlgorithm {
            get {
                return ResourceManager.GetString("UnsupportedChecksumAlgorithm", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to File path &apos;{0}&apos; does not belong to the directory &apos;{1}&apos;..
        /// </summary>
        internal static string VirtualFileSystem_FileDoesNotBelongToDirectory {
            get {
                return ResourceManager.GetString("VirtualFileSystem_FileDoesNotBelongToDirectory", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The file path &apos;{0}&apos; is invalid. File path is the root relative path of the file starting with &apos;/&apos; and should not contain any &apos;\&apos; characters..
        /// </summary>
        internal static string VirtualFileSystem_InvalidRelativePath {
            get {
                return ResourceManager.GetString("VirtualFileSystem_InvalidRelativePath", resourceCulture);
            }
        }
    }
}
