@typespec/html-program-viewer 0.67.0-dev.3 → 0.67.0-dev.5

package/dist/react/index.js

@@ -17882,233 +17882,6 @@ function normalizeSlashes(path) {
     return path.replace(backslashRegExp, directorySeparator);
 }
 
-function createSourceFile(text, path) {
-    let lineStarts = undefined;
-    return {
-        text,
-        path,
-        getLineStarts,
-        getLineAndCharacterOfPosition,
-    };
-    function getLineStarts() {
-        return (lineStarts = lineStarts ?? scanLineStarts(text));
-    }
-    function getLineAndCharacterOfPosition(position) {
-        const starts = getLineStarts();
-        let line = binarySearch(starts, position);
-        // When binarySearch returns < 0 indicating that the value was not found, it
-        // returns the bitwise complement of the index where the value would need to
-        // be inserted to keep the array sorted. So flipping the bits back to this
-        // positive index tells us what the line number would be if we were to
-        // create a new line starting at the given position, and subtracting 1 from
-        // that therefore gives us the line number we're after.
-        if (line < 0) {
-            line = ~line - 1;
-        }
-        return {
-            line,
-            character: position - starts[line],
-        };
-    }
-}
-function scanLineStarts(text) {
-    const starts = [];
-    let start = 0;
-    let pos = 0;
-    while (pos < text.length) {
-        const ch = text.charCodeAt(pos);
-        pos++;
-        switch (ch) {
-            case 13 /* CharCode.CarriageReturn */:
-                if (text.charCodeAt(pos) === 10 /* CharCode.LineFeed */) {
-                    pos++;
-                }
-            // fallthrough
-            case 10 /* CharCode.LineFeed */:
-                starts.push(start);
-                start = pos;
-                break;
-        }
-    }
-    starts.push(start);
-    return starts;
-}
-/**
- * Search sorted array of numbers for the given value. If found, return index
- * in array where value was found. If not found, return a negative number that
- * is the bitwise complement of the index where value would need to be inserted
- * to keep the array sorted.
- */
-function binarySearch(array, value) {
-    let low = 0;
-    let high = array.length - 1;
-    while (low <= high) {
-        const middle = low + ((high - low) >> 1);
-        const v = array[middle];
-        if (v < value) {
-            low = middle + 1;
-        }
-        else if (v > value) {
-            high = middle - 1;
-        }
-        else {
-            return middle;
-        }
-    }
-    return ~low;
-}
-
-var ResolutionResultFlags;
-(function (ResolutionResultFlags) {
-    ResolutionResultFlags[ResolutionResultFlags["None"] = 0] = "None";
-    ResolutionResultFlags[ResolutionResultFlags["Resolved"] = 2] = "Resolved";
-    ResolutionResultFlags[ResolutionResultFlags["Unknown"] = 4] = "Unknown";
-    ResolutionResultFlags[ResolutionResultFlags["Ambiguous"] = 8] = "Ambiguous";
-    ResolutionResultFlags[ResolutionResultFlags["NotFound"] = 16] = "NotFound";
-    ResolutionResultFlags[ResolutionResultFlags["ResolutionFailed"] = 28] = "ResolutionFailed";
-})(ResolutionResultFlags || (ResolutionResultFlags = {}));
-/**
- * AST types
- */
-var SyntaxKind;
-(function (SyntaxKind) {
-    SyntaxKind[SyntaxKind["TypeSpecScript"] = 0] = "TypeSpecScript";
-    SyntaxKind[SyntaxKind["JsSourceFile"] = 1] = "JsSourceFile";
-    SyntaxKind[SyntaxKind["ImportStatement"] = 2] = "ImportStatement";
-    SyntaxKind[SyntaxKind["Identifier"] = 3] = "Identifier";
-    SyntaxKind[SyntaxKind["AugmentDecoratorStatement"] = 4] = "AugmentDecoratorStatement";
-    SyntaxKind[SyntaxKind["DecoratorExpression"] = 5] = "DecoratorExpression";
-    SyntaxKind[SyntaxKind["DirectiveExpression"] = 6] = "DirectiveExpression";
-    SyntaxKind[SyntaxKind["MemberExpression"] = 7] = "MemberExpression";
-    SyntaxKind[SyntaxKind["NamespaceStatement"] = 8] = "NamespaceStatement";
-    SyntaxKind[SyntaxKind["UsingStatement"] = 9] = "UsingStatement";
-    SyntaxKind[SyntaxKind["OperationStatement"] = 10] = "OperationStatement";
-    SyntaxKind[SyntaxKind["OperationSignatureDeclaration"] = 11] = "OperationSignatureDeclaration";
-    SyntaxKind[SyntaxKind["OperationSignatureReference"] = 12] = "OperationSignatureReference";
-    SyntaxKind[SyntaxKind["ModelStatement"] = 13] = "ModelStatement";
-    SyntaxKind[SyntaxKind["ModelExpression"] = 14] = "ModelExpression";
-    SyntaxKind[SyntaxKind["ModelProperty"] = 15] = "ModelProperty";
-    SyntaxKind[SyntaxKind["ModelSpreadProperty"] = 16] = "ModelSpreadProperty";
-    SyntaxKind[SyntaxKind["ScalarStatement"] = 17] = "ScalarStatement";
-    SyntaxKind[SyntaxKind["InterfaceStatement"] = 18] = "InterfaceStatement";
-    SyntaxKind[SyntaxKind["UnionStatement"] = 19] = "UnionStatement";
-    SyntaxKind[SyntaxKind["UnionVariant"] = 20] = "UnionVariant";
-    SyntaxKind[SyntaxKind["EnumStatement"] = 21] = "EnumStatement";
-    SyntaxKind[SyntaxKind["EnumMember"] = 22] = "EnumMember";
-    SyntaxKind[SyntaxKind["EnumSpreadMember"] = 23] = "EnumSpreadMember";
-    SyntaxKind[SyntaxKind["AliasStatement"] = 24] = "AliasStatement";
-    SyntaxKind[SyntaxKind["DecoratorDeclarationStatement"] = 25] = "DecoratorDeclarationStatement";
-    SyntaxKind[SyntaxKind["FunctionDeclarationStatement"] = 26] = "FunctionDeclarationStatement";
-    SyntaxKind[SyntaxKind["FunctionParameter"] = 27] = "FunctionParameter";
-    SyntaxKind[SyntaxKind["UnionExpression"] = 28] = "UnionExpression";
-    SyntaxKind[SyntaxKind["IntersectionExpression"] = 29] = "IntersectionExpression";
-    SyntaxKind[SyntaxKind["TupleExpression"] = 30] = "TupleExpression";
-    SyntaxKind[SyntaxKind["ArrayExpression"] = 31] = "ArrayExpression";
-    SyntaxKind[SyntaxKind["StringLiteral"] = 32] = "StringLiteral";
-    SyntaxKind[SyntaxKind["NumericLiteral"] = 33] = "NumericLiteral";
-    SyntaxKind[SyntaxKind["BooleanLiteral"] = 34] = "BooleanLiteral";
-    SyntaxKind[SyntaxKind["StringTemplateExpression"] = 35] = "StringTemplateExpression";
-    SyntaxKind[SyntaxKind["StringTemplateHead"] = 36] = "StringTemplateHead";
-    SyntaxKind[SyntaxKind["StringTemplateMiddle"] = 37] = "StringTemplateMiddle";
-    SyntaxKind[SyntaxKind["StringTemplateTail"] = 38] = "StringTemplateTail";
-    SyntaxKind[SyntaxKind["StringTemplateSpan"] = 39] = "StringTemplateSpan";
-    SyntaxKind[SyntaxKind["ExternKeyword"] = 40] = "ExternKeyword";
-    SyntaxKind[SyntaxKind["VoidKeyword"] = 41] = "VoidKeyword";
-    SyntaxKind[SyntaxKind["NeverKeyword"] = 42] = "NeverKeyword";
-    SyntaxKind[SyntaxKind["UnknownKeyword"] = 43] = "UnknownKeyword";
-    SyntaxKind[SyntaxKind["ValueOfExpression"] = 44] = "ValueOfExpression";
-    SyntaxKind[SyntaxKind["TypeReference"] = 45] = "TypeReference";
-    SyntaxKind[SyntaxKind["ProjectionReference"] = 46] = "ProjectionReference";
-    SyntaxKind[SyntaxKind["TemplateParameterDeclaration"] = 47] = "TemplateParameterDeclaration";
-    SyntaxKind[SyntaxKind["EmptyStatement"] = 48] = "EmptyStatement";
-    SyntaxKind[SyntaxKind["InvalidStatement"] = 49] = "InvalidStatement";
-    SyntaxKind[SyntaxKind["LineComment"] = 50] = "LineComment";
-    SyntaxKind[SyntaxKind["BlockComment"] = 51] = "BlockComment";
-    SyntaxKind[SyntaxKind["Doc"] = 52] = "Doc";
-    SyntaxKind[SyntaxKind["DocText"] = 53] = "DocText";
-    SyntaxKind[SyntaxKind["DocParamTag"] = 54] = "DocParamTag";
-    SyntaxKind[SyntaxKind["DocPropTag"] = 55] = "DocPropTag";
-    SyntaxKind[SyntaxKind["DocReturnsTag"] = 56] = "DocReturnsTag";
-    SyntaxKind[SyntaxKind["DocErrorsTag"] = 57] = "DocErrorsTag";
-    SyntaxKind[SyntaxKind["DocTemplateTag"] = 58] = "DocTemplateTag";
-    SyntaxKind[SyntaxKind["DocUnknownTag"] = 59] = "DocUnknownTag";
-    SyntaxKind[SyntaxKind["Projection"] = 60] = "Projection";
-    SyntaxKind[SyntaxKind["ProjectionParameterDeclaration"] = 61] = "ProjectionParameterDeclaration";
-    SyntaxKind[SyntaxKind["ProjectionModelSelector"] = 62] = "ProjectionModelSelector";
-    SyntaxKind[SyntaxKind["ProjectionModelPropertySelector"] = 63] = "ProjectionModelPropertySelector";
-    SyntaxKind[SyntaxKind["ProjectionScalarSelector"] = 64] = "ProjectionScalarSelector";
-    SyntaxKind[SyntaxKind["ProjectionOperationSelector"] = 65] = "ProjectionOperationSelector";
-    SyntaxKind[SyntaxKind["ProjectionUnionSelector"] = 66] = "ProjectionUnionSelector";
-    SyntaxKind[SyntaxKind["ProjectionUnionVariantSelector"] = 67] = "ProjectionUnionVariantSelector";
-    SyntaxKind[SyntaxKind["ProjectionInterfaceSelector"] = 68] = "ProjectionInterfaceSelector";
-    SyntaxKind[SyntaxKind["ProjectionEnumSelector"] = 69] = "ProjectionEnumSelector";
-    SyntaxKind[SyntaxKind["ProjectionEnumMemberSelector"] = 70] = "ProjectionEnumMemberSelector";
-    SyntaxKind[SyntaxKind["ProjectionExpressionStatement"] = 71] = "ProjectionExpressionStatement";
-    SyntaxKind[SyntaxKind["ProjectionIfExpression"] = 72] = "ProjectionIfExpression";
-    SyntaxKind[SyntaxKind["ProjectionBlockExpression"] = 73] = "ProjectionBlockExpression";
-    SyntaxKind[SyntaxKind["ProjectionMemberExpression"] = 74] = "ProjectionMemberExpression";
-    SyntaxKind[SyntaxKind["ProjectionLogicalExpression"] = 75] = "ProjectionLogicalExpression";
-    SyntaxKind[SyntaxKind["ProjectionEqualityExpression"] = 76] = "ProjectionEqualityExpression";
-    SyntaxKind[SyntaxKind["ProjectionUnaryExpression"] = 77] = "ProjectionUnaryExpression";
-    SyntaxKind[SyntaxKind["ProjectionRelationalExpression"] = 78] = "ProjectionRelationalExpression";
-    SyntaxKind[SyntaxKind["ProjectionArithmeticExpression"] = 79] = "ProjectionArithmeticExpression";
-    SyntaxKind[SyntaxKind["ProjectionCallExpression"] = 80] = "ProjectionCallExpression";
-    SyntaxKind[SyntaxKind["ProjectionLambdaExpression"] = 81] = "ProjectionLambdaExpression";
-    SyntaxKind[SyntaxKind["ProjectionLambdaParameterDeclaration"] = 82] = "ProjectionLambdaParameterDeclaration";
-    SyntaxKind[SyntaxKind["ProjectionModelExpression"] = 83] = "ProjectionModelExpression";
-    SyntaxKind[SyntaxKind["ProjectionModelProperty"] = 84] = "ProjectionModelProperty";
-    SyntaxKind[SyntaxKind["ProjectionModelSpreadProperty"] = 85] = "ProjectionModelSpreadProperty";
-    SyntaxKind[SyntaxKind["ProjectionSpreadProperty"] = 86] = "ProjectionSpreadProperty";
-    SyntaxKind[SyntaxKind["ProjectionTupleExpression"] = 87] = "ProjectionTupleExpression";
-    SyntaxKind[SyntaxKind["ProjectionStatement"] = 88] = "ProjectionStatement";
-    SyntaxKind[SyntaxKind["ProjectionDecoratorReferenceExpression"] = 89] = "ProjectionDecoratorReferenceExpression";
-    SyntaxKind[SyntaxKind["Return"] = 90] = "Return";
-    SyntaxKind[SyntaxKind["JsNamespaceDeclaration"] = 91] = "JsNamespaceDeclaration";
-    SyntaxKind[SyntaxKind["TemplateArgument"] = 92] = "TemplateArgument";
-    SyntaxKind[SyntaxKind["TypeOfExpression"] = 93] = "TypeOfExpression";
-    SyntaxKind[SyntaxKind["ObjectLiteral"] = 94] = "ObjectLiteral";
-    SyntaxKind[SyntaxKind["ObjectLiteralProperty"] = 95] = "ObjectLiteralProperty";
-    SyntaxKind[SyntaxKind["ObjectLiteralSpreadProperty"] = 96] = "ObjectLiteralSpreadProperty";
-    SyntaxKind[SyntaxKind["ArrayLiteral"] = 97] = "ArrayLiteral";
-    SyntaxKind[SyntaxKind["ConstStatement"] = 98] = "ConstStatement";
-    SyntaxKind[SyntaxKind["CallExpression"] = 99] = "CallExpression";
-    SyntaxKind[SyntaxKind["ScalarConstructor"] = 100] = "ScalarConstructor";
-})(SyntaxKind || (SyntaxKind = {}));
-var IdentifierKind;
-(function (IdentifierKind) {
-    IdentifierKind[IdentifierKind["TypeReference"] = 0] = "TypeReference";
-    IdentifierKind[IdentifierKind["TemplateArgument"] = 1] = "TemplateArgument";
-    IdentifierKind[IdentifierKind["Decorator"] = 2] = "Decorator";
-    IdentifierKind[IdentifierKind["Function"] = 3] = "Function";
-    IdentifierKind[IdentifierKind["Using"] = 4] = "Using";
-    IdentifierKind[IdentifierKind["Declaration"] = 5] = "Declaration";
-    IdentifierKind[IdentifierKind["ModelExpressionProperty"] = 6] = "ModelExpressionProperty";
-    IdentifierKind[IdentifierKind["ModelStatementProperty"] = 7] = "ModelStatementProperty";
-    IdentifierKind[IdentifierKind["ObjectLiteralProperty"] = 8] = "ObjectLiteralProperty";
-    IdentifierKind[IdentifierKind["Other"] = 9] = "Other";
-})(IdentifierKind || (IdentifierKind = {}));
-/** Used to explicitly specify that a diagnostic has no target. */
-const NoTarget = Symbol.for("NoTarget");
-var ListenerFlow;
-(function (ListenerFlow) {
-    /**
-     * Do not navigate any containing or referenced type.
-     */
-    ListenerFlow[ListenerFlow["NoRecursion"] = 1] = "NoRecursion";
-})(ListenerFlow || (ListenerFlow = {}));
-
-let manifest;
-try {
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    manifest = (await import('../manifest-IEQ_iGDm.js')).default;
-}
-catch {
-    const name = "../dist/manifest.js";
-    manifest = (await import(/* @vite-ignore */ /* webpackIgnore: true */ name)).default;
-}
-manifest.version;
-
 /**
  * Recursively calls Object.freeze such that all objects and arrays
  * referenced are frozen.
@@ -18419,7 +18192,6 @@ const diagnostics = {
             unexpected: paramMessage `Unexpected token ${"token"}`,
             numericOrStringLiteral: "Expected numeric or string literal.",
             identifier: "Identifier expected.",
-            projectionDirection: "from or to expected.",
             expression: "Expression expected.",
             statement: "Statement expected.",
             property: "Property expected.",
@@ -18458,6 +18230,7 @@ const diagnostics = {
         severity: "error",
         messages: {
             default: "Keyword cannot be used as identifier.",
+            future: paramMessage `${"name"} is a reserved keyword`,
         },
     },
     "invalid-directive-location": {
@@ -18472,15 +18245,6 @@ const diagnostics = {
             default: paramMessage `Cannot decorate ${"nodeName"}.`,
         },
     },
-    "invalid-projection": {
-        severity: "error",
-        messages: {
-            default: "Invalid projection",
-            wrongType: "Non-projection can't be used to project",
-            noTo: "Projection missing to projection",
-            projectionError: paramMessage `An error occurred when projecting this type: ${"message"}`,
-        },
-    },
     "default-required": {
         severity: "error",
         messages: {
@@ -18675,7 +18439,8 @@ const diagnostics = {
         messages: {
             default: paramMessage `${"name"} refers to a type, but is being used as a value here.`,
             model: paramMessage `${"name"} refers to a model type, but is being used as a value here. Use #{} to create an object value.`,
-            tuple: paramMessage `${"name"} refers to a tuple type, but is being used as a value here. Use #[] to create an array value.`,
+            modelExpression: `Is a model expression type, but is being used as a value here. Use #{} to create an object value.`,
+            tuple: `Is a tuple type, but is being used as a value here. Use #[] to create an array value.`,
             templateConstraint: paramMessage `${"name"} template parameter can be a type but is being used as a value here.`,
         },
     },
@@ -18820,6 +18585,12 @@ const diagnostics = {
             default: "A function declaration must be prefixed with the 'extern' modifier.",
         },
     },
+    "function-unsupported": {
+        severity: "error",
+        messages: {
+            default: "Function are currently not supported.",
+        },
+    },
     "missing-implementation": {
         severity: "error",
         messages: {
@@ -28271,45 +28042,229 @@ function findYamlNode(file, path, kind = "value") {
     return current ?? undefined;
 }
 
-function getSourceLocation(target, options = {}) {
-    if (target === NoTarget || target === undefined) {
-        return undefined;
-    }
-    if ("file" in target) {
-        return target;
+function createSourceFile(text, path) {
+    let lineStarts = undefined;
+    return {
+        text,
+        path,
+        getLineStarts,
+        getLineAndCharacterOfPosition,
+    };
+    function getLineStarts() {
+        return (lineStarts = lineStarts ?? scanLineStarts(text));
     }
-    if (!("kind" in target) && !("entityKind" in target)) {
-        // TemplateInstanceTarget
-        if (!("declarations" in target)) {
-            return getSourceLocationOfNode(target.node, options);
-        }
-        // symbol
-        if (target.flags & 32768 /* SymbolFlags.Using */) {
-            target = target.symbolSource;
-        }
-        if (!target.declarations[0]) {
-            return createSyntheticSourceLocation();
+    function getLineAndCharacterOfPosition(position) {
+        const starts = getLineStarts();
+        let line = binarySearch(starts, position);
+        // When binarySearch returns < 0 indicating that the value was not found, it
+        // returns the bitwise complement of the index where the value would need to
+        // be inserted to keep the array sorted. So flipping the bits back to this
+        // positive index tells us what the line number would be if we were to
+        // create a new line starting at the given position, and subtracting 1 from
+        // that therefore gives us the line number we're after.
+        if (line < 0) {
+            line = ~line - 1;
         }
-        return getSourceLocationOfNode(target.declarations[0], options);
-    }
-    else if ("kind" in target && typeof target.kind === "number") {
-        // node
-        return getSourceLocationOfNode(target, options);
+        return {
+            line,
+            character: position - starts[line],
+        };
     }
-    else {
-        // type
-        const targetNode = target.node;
-        if (targetNode) {
-            return getSourceLocationOfNode(targetNode, options);
+}
+function scanLineStarts(text) {
+    const starts = [];
+    let start = 0;
+    let pos = 0;
+    while (pos < text.length) {
+        const ch = text.charCodeAt(pos);
+        pos++;
+        switch (ch) {
+            case 13 /* CharCode.CarriageReturn */:
+                if (text.charCodeAt(pos) === 10 /* CharCode.LineFeed */) {
+                    pos++;
+                }
+            // fallthrough
+            case 10 /* CharCode.LineFeed */:
+                starts.push(start);
+                start = pos;
+                break;
         }
-        return createSyntheticSourceLocation();
     }
+    starts.push(start);
+    return starts;
 }
-function createSyntheticSourceLocation(loc = "<unknown location>") {
-    return {
-        file: createSourceFile("", loc),
-        pos: 0,
-        end: 0,
+/**
+ * Search sorted array of numbers for the given value. If found, return index
+ * in array where value was found. If not found, return a negative number that
+ * is the bitwise complement of the index where value would need to be inserted
+ * to keep the array sorted.
+ */
+function binarySearch(array, value) {
+    let low = 0;
+    let high = array.length - 1;
+    while (low <= high) {
+        const middle = low + ((high - low) >> 1);
+        const v = array[middle];
+        if (v < value) {
+            low = middle + 1;
+        }
+        else if (v > value) {
+            high = middle - 1;
+        }
+        else {
+            return middle;
+        }
+    }
+    return ~low;
+}
+
+var ResolutionResultFlags;
+(function (ResolutionResultFlags) {
+    ResolutionResultFlags[ResolutionResultFlags["None"] = 0] = "None";
+    ResolutionResultFlags[ResolutionResultFlags["Resolved"] = 2] = "Resolved";
+    ResolutionResultFlags[ResolutionResultFlags["Unknown"] = 4] = "Unknown";
+    ResolutionResultFlags[ResolutionResultFlags["Ambiguous"] = 8] = "Ambiguous";
+    ResolutionResultFlags[ResolutionResultFlags["NotFound"] = 16] = "NotFound";
+    ResolutionResultFlags[ResolutionResultFlags["ResolutionFailed"] = 28] = "ResolutionFailed";
+})(ResolutionResultFlags || (ResolutionResultFlags = {}));
+/**
+ * AST types
+ */
+var SyntaxKind;
+(function (SyntaxKind) {
+    SyntaxKind[SyntaxKind["TypeSpecScript"] = 0] = "TypeSpecScript";
+    SyntaxKind[SyntaxKind["JsSourceFile"] = 1] = "JsSourceFile";
+    SyntaxKind[SyntaxKind["ImportStatement"] = 2] = "ImportStatement";
+    SyntaxKind[SyntaxKind["Identifier"] = 3] = "Identifier";
+    SyntaxKind[SyntaxKind["AugmentDecoratorStatement"] = 4] = "AugmentDecoratorStatement";
+    SyntaxKind[SyntaxKind["DecoratorExpression"] = 5] = "DecoratorExpression";
+    SyntaxKind[SyntaxKind["DirectiveExpression"] = 6] = "DirectiveExpression";
+    SyntaxKind[SyntaxKind["MemberExpression"] = 7] = "MemberExpression";
+    SyntaxKind[SyntaxKind["NamespaceStatement"] = 8] = "NamespaceStatement";
+    SyntaxKind[SyntaxKind["UsingStatement"] = 9] = "UsingStatement";
+    SyntaxKind[SyntaxKind["OperationStatement"] = 10] = "OperationStatement";
+    SyntaxKind[SyntaxKind["OperationSignatureDeclaration"] = 11] = "OperationSignatureDeclaration";
+    SyntaxKind[SyntaxKind["OperationSignatureReference"] = 12] = "OperationSignatureReference";
+    SyntaxKind[SyntaxKind["ModelStatement"] = 13] = "ModelStatement";
+    SyntaxKind[SyntaxKind["ModelExpression"] = 14] = "ModelExpression";
+    SyntaxKind[SyntaxKind["ModelProperty"] = 15] = "ModelProperty";
+    SyntaxKind[SyntaxKind["ModelSpreadProperty"] = 16] = "ModelSpreadProperty";
+    SyntaxKind[SyntaxKind["ScalarStatement"] = 17] = "ScalarStatement";
+    SyntaxKind[SyntaxKind["InterfaceStatement"] = 18] = "InterfaceStatement";
+    SyntaxKind[SyntaxKind["UnionStatement"] = 19] = "UnionStatement";
+    SyntaxKind[SyntaxKind["UnionVariant"] = 20] = "UnionVariant";
+    SyntaxKind[SyntaxKind["EnumStatement"] = 21] = "EnumStatement";
+    SyntaxKind[SyntaxKind["EnumMember"] = 22] = "EnumMember";
+    SyntaxKind[SyntaxKind["EnumSpreadMember"] = 23] = "EnumSpreadMember";
+    SyntaxKind[SyntaxKind["AliasStatement"] = 24] = "AliasStatement";
+    SyntaxKind[SyntaxKind["DecoratorDeclarationStatement"] = 25] = "DecoratorDeclarationStatement";
+    SyntaxKind[SyntaxKind["FunctionDeclarationStatement"] = 26] = "FunctionDeclarationStatement";
+    SyntaxKind[SyntaxKind["FunctionParameter"] = 27] = "FunctionParameter";
+    SyntaxKind[SyntaxKind["UnionExpression"] = 28] = "UnionExpression";
+    SyntaxKind[SyntaxKind["IntersectionExpression"] = 29] = "IntersectionExpression";
+    SyntaxKind[SyntaxKind["TupleExpression"] = 30] = "TupleExpression";
+    SyntaxKind[SyntaxKind["ArrayExpression"] = 31] = "ArrayExpression";
+    SyntaxKind[SyntaxKind["StringLiteral"] = 32] = "StringLiteral";
+    SyntaxKind[SyntaxKind["NumericLiteral"] = 33] = "NumericLiteral";
+    SyntaxKind[SyntaxKind["BooleanLiteral"] = 34] = "BooleanLiteral";
+    SyntaxKind[SyntaxKind["StringTemplateExpression"] = 35] = "StringTemplateExpression";
+    SyntaxKind[SyntaxKind["StringTemplateHead"] = 36] = "StringTemplateHead";
+    SyntaxKind[SyntaxKind["StringTemplateMiddle"] = 37] = "StringTemplateMiddle";
+    SyntaxKind[SyntaxKind["StringTemplateTail"] = 38] = "StringTemplateTail";
+    SyntaxKind[SyntaxKind["StringTemplateSpan"] = 39] = "StringTemplateSpan";
+    SyntaxKind[SyntaxKind["ExternKeyword"] = 40] = "ExternKeyword";
+    SyntaxKind[SyntaxKind["VoidKeyword"] = 41] = "VoidKeyword";
+    SyntaxKind[SyntaxKind["NeverKeyword"] = 42] = "NeverKeyword";
+    SyntaxKind[SyntaxKind["UnknownKeyword"] = 43] = "UnknownKeyword";
+    SyntaxKind[SyntaxKind["ValueOfExpression"] = 44] = "ValueOfExpression";
+    SyntaxKind[SyntaxKind["TypeReference"] = 45] = "TypeReference";
+    SyntaxKind[SyntaxKind["TemplateParameterDeclaration"] = 46] = "TemplateParameterDeclaration";
+    SyntaxKind[SyntaxKind["EmptyStatement"] = 47] = "EmptyStatement";
+    SyntaxKind[SyntaxKind["InvalidStatement"] = 48] = "InvalidStatement";
+    SyntaxKind[SyntaxKind["LineComment"] = 49] = "LineComment";
+    SyntaxKind[SyntaxKind["BlockComment"] = 50] = "BlockComment";
+    SyntaxKind[SyntaxKind["Doc"] = 51] = "Doc";
+    SyntaxKind[SyntaxKind["DocText"] = 52] = "DocText";
+    SyntaxKind[SyntaxKind["DocParamTag"] = 53] = "DocParamTag";
+    SyntaxKind[SyntaxKind["DocPropTag"] = 54] = "DocPropTag";
+    SyntaxKind[SyntaxKind["DocReturnsTag"] = 55] = "DocReturnsTag";
+    SyntaxKind[SyntaxKind["DocErrorsTag"] = 56] = "DocErrorsTag";
+    SyntaxKind[SyntaxKind["DocTemplateTag"] = 57] = "DocTemplateTag";
+    SyntaxKind[SyntaxKind["DocUnknownTag"] = 58] = "DocUnknownTag";
+    SyntaxKind[SyntaxKind["Return"] = 59] = "Return";
+    SyntaxKind[SyntaxKind["JsNamespaceDeclaration"] = 60] = "JsNamespaceDeclaration";
+    SyntaxKind[SyntaxKind["TemplateArgument"] = 61] = "TemplateArgument";
+    SyntaxKind[SyntaxKind["TypeOfExpression"] = 62] = "TypeOfExpression";
+    SyntaxKind[SyntaxKind["ObjectLiteral"] = 63] = "ObjectLiteral";
+    SyntaxKind[SyntaxKind["ObjectLiteralProperty"] = 64] = "ObjectLiteralProperty";
+    SyntaxKind[SyntaxKind["ObjectLiteralSpreadProperty"] = 65] = "ObjectLiteralSpreadProperty";
+    SyntaxKind[SyntaxKind["ArrayLiteral"] = 66] = "ArrayLiteral";
+    SyntaxKind[SyntaxKind["ConstStatement"] = 67] = "ConstStatement";
+    SyntaxKind[SyntaxKind["CallExpression"] = 68] = "CallExpression";
+    SyntaxKind[SyntaxKind["ScalarConstructor"] = 69] = "ScalarConstructor";
+})(SyntaxKind || (SyntaxKind = {}));
+var IdentifierKind;
+(function (IdentifierKind) {
+    IdentifierKind[IdentifierKind["TypeReference"] = 0] = "TypeReference";
+    IdentifierKind[IdentifierKind["TemplateArgument"] = 1] = "TemplateArgument";
+    IdentifierKind[IdentifierKind["Decorator"] = 2] = "Decorator";
+    IdentifierKind[IdentifierKind["Function"] = 3] = "Function";
+    IdentifierKind[IdentifierKind["Using"] = 4] = "Using";
+    IdentifierKind[IdentifierKind["Declaration"] = 5] = "Declaration";
+    IdentifierKind[IdentifierKind["ModelExpressionProperty"] = 6] = "ModelExpressionProperty";
+    IdentifierKind[IdentifierKind["ModelStatementProperty"] = 7] = "ModelStatementProperty";
+    IdentifierKind[IdentifierKind["ObjectLiteralProperty"] = 8] = "ObjectLiteralProperty";
+    IdentifierKind[IdentifierKind["Other"] = 9] = "Other";
+})(IdentifierKind || (IdentifierKind = {}));
+/** Used to explicitly specify that a diagnostic has no target. */
+const NoTarget = Symbol.for("NoTarget");
+var ListenerFlow;
+(function (ListenerFlow) {
+    /**
+     * Do not navigate any containing or referenced type.
+     */
+    ListenerFlow[ListenerFlow["NoRecursion"] = 1] = "NoRecursion";
+})(ListenerFlow || (ListenerFlow = {}));
+
+function getSourceLocation(target, options = {}) {
+    if (target === NoTarget || target === undefined) {
+        return undefined;
+    }
+    if ("file" in target) {
+        return target;
+    }
+    if (!("kind" in target) && !("entityKind" in target)) {
+        // TemplateInstanceTarget
+        if (!("declarations" in target)) {
+            return getSourceLocationOfNode(target.node, options);
+        }
+        // symbol
+        if (target.flags & 8192 /* SymbolFlags.Using */) {
+            target = target.symbolSource;
+        }
+        if (!target.declarations[0]) {
+            return createSyntheticSourceLocation();
+        }
+        return getSourceLocationOfNode(target.declarations[0], options);
+    }
+    else if ("kind" in target && typeof target.kind === "number") {
+        // node
+        return getSourceLocationOfNode(target, options);
+    }
+    else {
+        // type
+        const targetNode = target.node;
+        if (targetNode) {
+            return getSourceLocationOfNode(targetNode, options);
+        }
+        return createSyntheticSourceLocation();
+    }
+}
+function createSyntheticSourceLocation(loc = "<unknown location>") {
+    return {
+        file: createSourceFile("", loc),
+        pos: 0,
+        end: 0,
         isSynthetic: true,
     };
 }
@@ -29230,9 +29185,7 @@ function getVisibilityForClass(program, property, visibilityClass) {
 // #endregion
 
 function isIntrinsicType(program, type, kind) {
-    return ignoreDiagnostics(program.checker.isTypeAssignableTo(
-    // eslint-disable-next-line @typescript-eslint/no-deprecated
-    type.projectionBase ?? type, program.checker.getStdType(kind), type));
+    return ignoreDiagnostics(program.checker.isTypeAssignableTo(type, program.checker.getStdType(kind), type));
 }
 
 const deprecatedKey = createStateSymbol("deprecated");
@@ -29361,61 +29314,170 @@ function getDiscriminator(program, entity) {
 const [getDiscriminatedOptions, setDiscriminatedOptions] = useStateMap(createStateSymbol("discriminated"));
 // #endregion
 
-const regex = /^(application|audio|font|example|image|message|model|multipart|text|video|x-(?:[0-9A-Za-z!#$%&'*+.^_`|~-]+))\/([0-9A-Za-z!#$%&'*+.^_`|~-]+)$/;
-function parseMimeType(mimeType) {
-    const match = mimeType.match(regex);
-    if (match == null) {
-        return undefined;
+function getDiscriminatedUnion(typeOrProgram, typeOrDiscriminator) {
+    return getDiscriminatedUnionForUnion(typeOrProgram, typeOrDiscriminator);
+}
+function getDiscriminatedUnionForUnion(program, type) {
+    const options = getDiscriminatedOptions(program, type);
+    const diagnostics = [];
+    if (options === undefined) {
+        return [undefined, []];
     }
-    const type = {
-        type: match[1],
-        ...parseSubType(match[2]),
+    const variants = new Map();
+    let defaultVariant;
+    // If there is not envelope then every variant needs to be a model.
+    for (const variant of type.variants.values()) {
+        if (typeof variant.name !== "string") {
+            if (defaultVariant) {
+                diagnostics.push(createDiagnostic({
+                    code: "invalid-discriminated-union-variant",
+                    messageId: "duplicateDefaultVariant",
+                    target: variant,
+                }));
+            }
+            else {
+                defaultVariant = variant.type;
+            }
+            continue;
+        }
+        variants.set(variant.name, variant.type);
+        if (options.envelope === "none") {
+            if (variant.type.kind !== "Model") {
+                diagnostics.push(createDiagnostic({
+                    code: "invalid-discriminated-union-variant",
+                    messageId: "noEnvelopeModel",
+                    format: { name: variant.name.toString() },
+                    target: variant,
+                }));
+                continue;
+            }
+            const prop = variant.type.properties.get(options.discriminatorPropertyName);
+            if (prop !== undefined) {
+                const key = getStringValue(prop.type);
+                if (key !== variant.name) {
+                    diagnostics.push(createDiagnostic({
+                        code: "invalid-discriminated-union-variant",
+                        messageId: "discriminantMismatch",
+                        format: {
+                            name: variant.name.toString(),
+                            discriminant: options.discriminatorPropertyName,
+                            propertyValue: key,
+                            variantName: String(variant.name),
+                        },
+                        target: variant.type,
+                    }));
+                }
+            }
+        }
+    }
+    return [
+        {
+            type,
+            options,
+            variants,
+        },
+        diagnostics,
+    ];
+}
+function getDiscriminatedUnionFromInheritance(type, discriminator) {
+    const variants = new Map();
+    const diagnostics = [];
+    const duplicates = new DuplicateTracker();
+    function checkForVariantsIn(current) {
+        for (const derivedModel of current.derivedModels) {
+            if (isTemplateDeclarationOrInstance(derivedModel)) {
+                continue; // Skip template instances as they should be used with `model is`
+            }
+            const keys = getDiscriminatorValues(derivedModel, discriminator, diagnostics);
+            if (keys === undefined) {
+                if (derivedModel.derivedModels.length === 0) {
+                    diagnostics.push(createDiagnostic({
+                        code: "missing-discriminator-property",
+                        format: { discriminator: discriminator.propertyName },
+                        target: derivedModel,
+                    }));
+                }
+                else {
+                    checkForVariantsIn(derivedModel);
+                }
+            }
+            else {
+                for (const key of keys) {
+                    duplicates.track(key, derivedModel);
+                    variants.set(key, derivedModel);
+                }
+            }
+        }
+    }
+    checkForVariantsIn(type);
+    reportDuplicateDiscriminatorValues(duplicates, diagnostics);
+    const discriminatedUnion = {
+        kind: "legacy",
+        propertyName: discriminator.propertyName,
+        variants,
     };
-    return type;
+    return [discriminatedUnion, diagnostics];
 }
-function parseSubType(value) {
-    if (!value.includes("+"))
-        return { subtype: value };
-    const [subtype, suffix] = value.split("+", 2);
-    return { subtype, suffix };
+function reportDuplicateDiscriminatorValues(duplicates, diagnostics) {
+    for (const [duplicateKey, models] of duplicates.entries()) {
+        for (const model of models) {
+            diagnostics.push(createDiagnostic({
+                code: "invalid-discriminator-value",
+                messageId: "duplicate",
+                format: { discriminator: duplicateKey },
+                target: model,
+            }));
+        }
+    }
 }
-
-const [getEncodedNamesMap, setEncodedNamesMap, getEncodedNamesStateMap] = useStateMap(createStateSymbol("encodedName"));
-function getEncodedName(program, target, mimeType) {
-    const mimeTypeObj = parseMimeType(mimeType);
-    if (mimeTypeObj === undefined) {
+function getDiscriminatorProperty(model, discriminator, diagnostics) {
+    const prop = model.properties.get(discriminator.propertyName);
+    if (prop && prop.optional) {
+        diagnostics.push(createDiagnostic({
+            code: "invalid-discriminator-value",
+            messageId: "required",
+            target: prop,
+        }));
+    }
+    return prop;
+}
+function getDiscriminatorValues(model, discriminator, diagnostics) {
+    const prop = getDiscriminatorProperty(model, discriminator, diagnostics);
+    if (!prop)
         return undefined;
+    const keys = getStringValues(prop.type);
+    if (keys.length === 0) {
+        diagnostics.push(createDiagnostic({
+            code: "invalid-discriminator-value",
+            format: { kind: prop.type.kind },
+            target: prop,
+        }));
     }
-    const resolvedMimeType = mimeTypeObj?.suffix
-        ? `${mimeTypeObj.type}/${mimeTypeObj.suffix}`
-        : mimeType;
-    return getEncodedNamesMap(program, target)?.get(resolvedMimeType);
+    return keys;
 }
-/**
- * Resolve the encoded name for the given type when serialized to the given mime type.
- * If a specific value was provided by `@encodedName` decorator for that mime type it will return that otherwise it will return the name of the type.
- *
- * @example
- *
- * For the given
- * ```tsp
- * model Certificate {
- *   @encodedName("application/json", "exp")
- *   @encodedName("application/xml", "expiry")
- *   expireAt: utcDateTime;
- *
- * }
- * ```
- *
- * ```ts
- * resolveEncodedName(program, type, "application/json") // exp
- * resolveEncodedName(program, type, "application/merge-patch+json") // exp
- * resolveEncodedName(program, type, "application/xml") // expireAt
- * resolveEncodedName(program, type, "application/yaml") // expiry
- * ```
- */
-function resolveEncodedName(program, target, mimeType) {
-    return getEncodedName(program, target, mimeType) ?? target.name;
+function getStringValues(type) {
+    switch (type.kind) {
+        case "String":
+            return [type.value];
+        case "Union":
+            return [...type.variants.values()].flatMap((x) => getStringValues(x.type)).filter(isDefined);
+        case "EnumMember":
+            return typeof type.value !== "number" ? [type.value ?? type.name] : [];
+        case "UnionVariant":
+            return getStringValues(type.type);
+        default:
+            return [];
+    }
+}
+function getStringValue(type) {
+    switch (type.kind) {
+        case "String":
+            return type.value;
+        case "EnumMember":
+            return typeof type.value !== "number" ? (type.value ?? type.name) : undefined;
+        default:
+            return undefined;
+    }
 }
 
 //
@@ -30304,7 +30366,42 @@ var Token;
     // Add new non-statement keyword above
     /** @internal */ Token[Token["__EndKeyword"] = 80] = "__EndKeyword";
     ///////////////////////////////////////////////////////////////
-    /** @internal */ Token[Token["__Count"] = 80] = "__Count";
+    /** @internal */ Token[Token["__StartReservedKeyword"] = 80] = "__StartReservedKeyword";
+    ///////////////////////////////////////////////////////////////
+    // List of keywords that have special meaning in the language but are reserved for future use
+    Token[Token["StatemachineKeyword"] = 80] = "StatemachineKeyword";
+    Token[Token["MacroKeyword"] = 81] = "MacroKeyword";
+    Token[Token["PackageKeyword"] = 82] = "PackageKeyword";
+    Token[Token["MetadataKeyword"] = 83] = "MetadataKeyword";
+    Token[Token["EnvKeyword"] = 84] = "EnvKeyword";
+    Token[Token["ArgKeyword"] = 85] = "ArgKeyword";
+    Token[Token["DeclareKeyword"] = 86] = "DeclareKeyword";
+    Token[Token["ArrayKeyword"] = 87] = "ArrayKeyword";
+    Token[Token["StructKeyword"] = 88] = "StructKeyword";
+    Token[Token["RecordKeyword"] = 89] = "RecordKeyword";
+    Token[Token["ModuleKeyword"] = 90] = "ModuleKeyword";
+    Token[Token["TraitKeyword"] = 91] = "TraitKeyword";
+    Token[Token["ThisKeyword"] = 92] = "ThisKeyword";
+    Token[Token["SelfKeyword"] = 93] = "SelfKeyword";
+    Token[Token["SuperKeyword"] = 94] = "SuperKeyword";
+    Token[Token["KeyofKeyword"] = 95] = "KeyofKeyword";
+    Token[Token["WithKeyword"] = 96] = "WithKeyword";
+    Token[Token["ImplementsKeyword"] = 97] = "ImplementsKeyword";
+    Token[Token["ImplKeyword"] = 98] = "ImplKeyword";
+    Token[Token["SatisfiesKeyword"] = 99] = "SatisfiesKeyword";
+    Token[Token["FlagKeyword"] = 100] = "FlagKeyword";
+    Token[Token["AutoKeyword"] = 101] = "AutoKeyword";
+    Token[Token["PartialKeyword"] = 102] = "PartialKeyword";
+    Token[Token["PrivateKeyword"] = 103] = "PrivateKeyword";
+    Token[Token["PublicKeyword"] = 104] = "PublicKeyword";
+    Token[Token["ProtectedKeyword"] = 105] = "ProtectedKeyword";
+    Token[Token["InternalKeyword"] = 106] = "InternalKeyword";
+    Token[Token["SealedKeyword"] = 107] = "SealedKeyword";
+    Token[Token["LocalKeyword"] = 108] = "LocalKeyword";
+    Token[Token["AsyncKeyword"] = 109] = "AsyncKeyword";
+    /** @internal */ Token[Token["__EndReservedKeyword"] = 110] = "__EndReservedKeyword";
+    ///////////////////////////////////////////////////////////////
+    /** @internal */ Token[Token["__Count"] = 110] = "__Count";
 })(Token || (Token = {}));
 /** @internal */
 getTokenDisplayTable([
@@ -30388,6 +30485,37 @@ getTokenDisplayTable([
     [Token.NeverKeyword, "'never'"],
     [Token.UnknownKeyword, "'unknown'"],
     [Token.ExternKeyword, "'extern'"],
+    // Reserved keywords
+    [Token.StatemachineKeyword, "'statemachine'"],
+    [Token.MacroKeyword, "'macro'"],
+    [Token.PackageKeyword, "'package'"],
+    [Token.MetadataKeyword, "'metadata'"],
+    [Token.EnvKeyword, "'env'"],
+    [Token.ArgKeyword, "'arg'"],
+    [Token.DeclareKeyword, "'declare'"],
+    [Token.ArrayKeyword, "'array'"],
+    [Token.StructKeyword, "'struct'"],
+    [Token.RecordKeyword, "'record'"],
+    [Token.ModuleKeyword, "'module'"],
+    [Token.TraitKeyword, "'trait'"],
+    [Token.ThisKeyword, "'this'"],
+    [Token.SelfKeyword, "'self'"],
+    [Token.SuperKeyword, "'super'"],
+    [Token.KeyofKeyword, "'keyof'"],
+    [Token.WithKeyword, "'with'"],
+    [Token.ImplementsKeyword, "'implements'"],
+    [Token.ImplKeyword, "'impl'"],
+    [Token.SatisfiesKeyword, "'satisfies'"],
+    [Token.FlagKeyword, "'flag'"],
+    [Token.AutoKeyword, "'auto'"],
+    [Token.PartialKeyword, "'partial'"],
+    [Token.PrivateKeyword, "'private'"],
+    [Token.PublicKeyword, "'public'"],
+    [Token.ProtectedKeyword, "'protected'"],
+    [Token.InternalKeyword, "'internal'"],
+    [Token.SealedKeyword, "'sealed'"],
+    [Token.LocalKeyword, "'local'"],
+    [Token.AsyncKeyword, "'async'"],
 ]);
 /** @internal */
 const Keywords = new Map([
@@ -30419,6 +30547,71 @@ const Keywords = new Map([
     ["never", Token.NeverKeyword],
     ["unknown", Token.UnknownKeyword],
     ["extern", Token.ExternKeyword],
+    // Reserved keywords
+    ["statemachine", Token.StatemachineKeyword],
+    ["macro", Token.MacroKeyword],
+    ["package", Token.PackageKeyword],
+    ["metadata", Token.MetadataKeyword],
+    ["env", Token.EnvKeyword],
+    ["arg", Token.ArgKeyword],
+    ["declare", Token.DeclareKeyword],
+    ["array", Token.ArrayKeyword],
+    ["struct", Token.StructKeyword],
+    ["record", Token.RecordKeyword],
+    ["module", Token.ModuleKeyword],
+    ["trait", Token.TraitKeyword],
+    ["this", Token.ThisKeyword],
+    ["self", Token.SelfKeyword],
+    ["super", Token.SuperKeyword],
+    ["keyof", Token.KeyofKeyword],
+    ["with", Token.WithKeyword],
+    ["implements", Token.ImplementsKeyword],
+    ["impl", Token.ImplKeyword],
+    ["satisfies", Token.SatisfiesKeyword],
+    ["flag", Token.FlagKeyword],
+    ["auto", Token.AutoKeyword],
+    ["partial", Token.PartialKeyword],
+    ["private", Token.PrivateKeyword],
+    ["public", Token.PublicKeyword],
+    ["protected", Token.ProtectedKeyword],
+    ["internal", Token.InternalKeyword],
+    ["sealed", Token.SealedKeyword],
+    ["local", Token.LocalKeyword],
+    ["async", Token.AsyncKeyword],
+]);
+/** @internal */
+const ReservedKeywords = new Map([
+    // Reserved keywords
+    ["statemachine", Token.StatemachineKeyword],
+    ["macro", Token.MacroKeyword],
+    ["package", Token.PackageKeyword],
+    ["metadata", Token.MetadataKeyword],
+    ["env", Token.EnvKeyword],
+    ["arg", Token.ArgKeyword],
+    ["declare", Token.DeclareKeyword],
+    ["array", Token.ArrayKeyword],
+    ["struct", Token.StructKeyword],
+    ["record", Token.RecordKeyword],
+    ["module", Token.ModuleKeyword],
+    ["trait", Token.TraitKeyword],
+    ["this", Token.ThisKeyword],
+    ["self", Token.SelfKeyword],
+    ["super", Token.SuperKeyword],
+    ["keyof", Token.KeyofKeyword],
+    ["with", Token.WithKeyword],
+    ["implements", Token.ImplementsKeyword],
+    ["impl", Token.ImplKeyword],
+    ["satisfies", Token.SatisfiesKeyword],
+    ["flag", Token.FlagKeyword],
+    ["auto", Token.AutoKeyword],
+    ["partial", Token.PartialKeyword],
+    ["private", Token.PrivateKeyword],
+    ["public", Token.PublicKeyword],
+    ["protected", Token.ProtectedKeyword],
+    ["internal", Token.InternalKeyword],
+    ["sealed", Token.SealedKeyword],
+    ["local", Token.LocalKeyword],
+    ["async", Token.AsyncKeyword],
 ]);
 var TokenFlags;
 (function (TokenFlags) {
@@ -30454,8 +30647,9 @@ function getTokenDisplayTable(entries) {
  * printIdentifier("foo bar") // `foo bar`
  * ```
  */
-function printIdentifier(sv) {
-    if (needBacktick(sv)) {
+function printIdentifier(sv, 
+/** @internal */ context = "disallow-reserved") {
+    if (needBacktick(sv, context)) {
         const escapedString = sv
             .replace(/\\/g, "\\\\")
             .replace(/\n/g, "\\n")
@@ -30468,10 +30662,13 @@ function printIdentifier(sv) {
         return sv;
     }
 }
-function needBacktick(sv) {
+function needBacktick(sv, context) {
     if (sv.length === 0) {
         return false;
     }
+    if (context === "allow-reserved" && ReservedKeywords.has(sv)) {
+        return false;
+    }
     if (Keywords.has(sv)) {
         return true;
     }
@@ -30678,11 +30875,76 @@ function getOperationName(op, options) {
 function getIdentifierName(name, options) {
     return options?.printable ? printIdentifier(name) : name;
 }
-function getStringTemplateName(type) {
-    if (type.stringValue) {
-        return `"${type.stringValue}"`;
+function getStringTemplateName(type) {
+    if (type.stringValue) {
+        return `"${type.stringValue}"`;
+    }
+    return "string";
+}
+
+const regex = /^(application|audio|font|example|image|message|model|multipart|text|video|x-(?:[0-9A-Za-z!#$%&'*+.^_`|~-]+))\/([0-9A-Za-z!#$%&'*+.^_`|~-]+)$/;
+function parseMimeType(mimeType) {
+    const match = mimeType.match(regex);
+    if (match == null) {
+        return undefined;
+    }
+    const type = {
+        type: match[1],
+        ...parseSubType(match[2]),
+    };
+    return type;
+}
+function parseSubType(value) {
+    if (!value.includes("+"))
+        return { subtype: value };
+    const [subtype, suffix] = value.split("+", 2);
+    return { subtype, suffix };
+}
+
+const [getEncodedNamesMap, setEncodedNamesMap, getEncodedNamesStateMap] = useStateMap(createStateSymbol("encodedName"));
+function getEncodedName(program, target, mimeType) {
+    const mimeTypeObj = parseMimeType(mimeType);
+    if (mimeTypeObj === undefined) {
+        return undefined;
+    }
+    const resolvedMimeType = mimeTypeObj?.suffix
+        ? `${mimeTypeObj.type}/${mimeTypeObj.suffix}`
+        : mimeType;
+    return getEncodedNamesMap(program, target)?.get(resolvedMimeType);
+}
+/**
+ * Resolve the encoded name for the given type when serialized to the given mime type.
+ * If a specific value was provided by `@encodedName` decorator for that mime type it will return that otherwise it will return the name of the type.
+ *
+ * @example
+ *
+ * For the given
+ * ```tsp
+ * model Certificate {
+ *   @encodedName("application/json", "exp")
+ *   @encodedName("application/xml", "expiry")
+ *   expireAt: utcDateTime;
+ *
+ * }
+ * ```
+ *
+ * ```ts
+ * resolveEncodedName(program, type, "application/json") // exp
+ * resolveEncodedName(program, type, "application/merge-patch+json") // exp
+ * resolveEncodedName(program, type, "application/xml") // expireAt
+ * resolveEncodedName(program, type, "application/yaml") // expiry
+ * ```
+ */
+function resolveEncodedName(program, target, mimeType) {
+    return getEncodedName(program, target, mimeType) ?? target.name;
+}
+
+function getLocationContext(program, type) {
+    const sourceLocation = getSourceLocation(type);
+    if (sourceLocation.isSynthetic) {
+        return { type: "synthetic" };
     }
-    return "string";
+    return program.getSourceFileLocationContext(sourceLocation.file);
 }
 
 /**
@@ -30842,6 +31104,13 @@ defineKit({
             }
             return undefined;
         },
+        getDiscriminatedUnion(model) {
+            const discriminator = getDiscriminator(this.program, model);
+            if (!discriminator) {
+                return undefined;
+            }
+            return ignoreDiagnostics(getDiscriminatedUnionFromInheritance(model, discriminator));
+        },
     },
 });
 
@@ -30984,228 +31253,6 @@ function extendsStdType(typeName) {
     };
 }
 
-function getDiscriminatedUnion(typeOrProgram, typeOrDiscriminator) {
-    if ("propertyName" in typeOrDiscriminator) {
-        const type = typeOrProgram;
-        switch (type.kind) {
-            case "Model":
-                return getDiscriminatedUnionFromInheritance(type, typeOrDiscriminator);
-            case "Union":
-                return getDiscriminatedUnionForUnionLegacy(type, typeOrDiscriminator);
-        }
-    }
-    else {
-        return getDiscriminatedUnionForUnion(typeOrProgram, typeOrDiscriminator);
-    }
-}
-function getDiscriminatedUnionForUnion(program, type) {
-    const options = getDiscriminatedOptions(program, type);
-    const diagnostics = [];
-    if (options === undefined) {
-        return [undefined, []];
-    }
-    const variants = new Map();
-    let defaultVariant;
-    // If there is not envelope then every variant needs to be a model.
-    for (const variant of type.variants.values()) {
-        if (typeof variant.name !== "string") {
-            if (defaultVariant) {
-                diagnostics.push(createDiagnostic({
-                    code: "invalid-discriminated-union-variant",
-                    messageId: "duplicateDefaultVariant",
-                    target: variant,
-                }));
-            }
-            else {
-                defaultVariant = variant.type;
-            }
-            continue;
-        }
-        variants.set(variant.name, variant.type);
-        if (options.envelope === "none") {
-            if (variant.type.kind !== "Model") {
-                diagnostics.push(createDiagnostic({
-                    code: "invalid-discriminated-union-variant",
-                    messageId: "noEnvelopeModel",
-                    format: { name: variant.name.toString() },
-                    target: variant,
-                }));
-                continue;
-            }
-            const prop = variant.type.properties.get(options.discriminatorPropertyName);
-            if (prop !== undefined) {
-                const key = getStringValue(prop.type);
-                if (key !== variant.name) {
-                    diagnostics.push(createDiagnostic({
-                        code: "invalid-discriminated-union-variant",
-                        messageId: "discriminantMismatch",
-                        format: {
-                            name: variant.name.toString(),
-                            discriminant: options.discriminatorPropertyName,
-                            propertyValue: key,
-                            variantName: String(variant.name),
-                        },
-                        target: variant.type,
-                    }));
-                }
-            }
-        }
-    }
-    return [
-        {
-            type,
-            options,
-            variants,
-        },
-        diagnostics,
-    ];
-}
-function getDiscriminatedUnionForUnionLegacy(type, discriminator) {
-    const variants = new Map();
-    const diagnostics = [];
-    const duplicates = new DuplicateTracker();
-    for (const variant of type.variants.values()) {
-        if (variant.type.kind !== "Model") {
-            diagnostics.push(createDiagnostic({
-                code: "invalid-discriminated-union-variant",
-                format: { name: variant.name.toString() },
-                target: variant,
-            }));
-            continue;
-        }
-        const prop = getDiscriminatorProperty(variant.type, discriminator, diagnostics);
-        if (prop === undefined) {
-            diagnostics.push(createDiagnostic({
-                code: "invalid-discriminated-union-variant",
-                messageId: "noDiscriminant",
-                format: { name: variant.name.toString(), discriminant: discriminator.propertyName },
-                target: variant,
-            }));
-            continue;
-        }
-        const key = getStringValue(prop.type);
-        if (key) {
-            duplicates.track(key, variant.type);
-            variants.set(key, variant.type);
-        }
-        else {
-            diagnostics.push(createDiagnostic({
-                code: "invalid-discriminated-union-variant",
-                messageId: "wrongDiscriminantType",
-                format: { name: variant.name.toString(), discriminant: discriminator.propertyName },
-                target: variant.type,
-            }));
-        }
-    }
-    reportDuplicateDiscriminatorValues(duplicates, diagnostics);
-    const discriminatedUnion = {
-        kind: "legacy",
-        propertyName: discriminator.propertyName,
-        variants,
-    };
-    return [discriminatedUnion, diagnostics];
-}
-function getDiscriminatedUnionFromInheritance(type, discriminator) {
-    const variants = new Map();
-    const diagnostics = [];
-    const duplicates = new DuplicateTracker();
-    function checkForVariantsIn(current) {
-        for (const derivedModel of current.derivedModels) {
-            if (isTemplateDeclarationOrInstance(derivedModel)) {
-                continue; // Skip template instances as they should be used with `model is`
-            }
-            const keys = getDiscriminatorValues(derivedModel, discriminator, diagnostics);
-            if (keys === undefined) {
-                if (derivedModel.derivedModels.length === 0) {
-                    diagnostics.push(createDiagnostic({
-                        code: "missing-discriminator-property",
-                        format: { discriminator: discriminator.propertyName },
-                        target: derivedModel,
-                    }));
-                }
-                else {
-                    checkForVariantsIn(derivedModel);
-                }
-            }
-            else {
-                for (const key of keys) {
-                    duplicates.track(key, derivedModel);
-                    variants.set(key, derivedModel);
-                }
-            }
-        }
-    }
-    checkForVariantsIn(type);
-    reportDuplicateDiscriminatorValues(duplicates, diagnostics);
-    const discriminatedUnion = {
-        kind: "legacy",
-        propertyName: discriminator.propertyName,
-        variants,
-    };
-    return [discriminatedUnion, diagnostics];
-}
-function reportDuplicateDiscriminatorValues(duplicates, diagnostics) {
-    for (const [duplicateKey, models] of duplicates.entries()) {
-        for (const model of models) {
-            diagnostics.push(createDiagnostic({
-                code: "invalid-discriminator-value",
-                messageId: "duplicate",
-                format: { discriminator: duplicateKey },
-                target: model,
-            }));
-        }
-    }
-}
-function getDiscriminatorProperty(model, discriminator, diagnostics) {
-    const prop = model.properties.get(discriminator.propertyName);
-    if (prop && prop.optional) {
-        diagnostics.push(createDiagnostic({
-            code: "invalid-discriminator-value",
-            messageId: "required",
-            target: prop,
-        }));
-    }
-    return prop;
-}
-function getDiscriminatorValues(model, discriminator, diagnostics) {
-    const prop = getDiscriminatorProperty(model, discriminator, diagnostics);
-    if (!prop)
-        return undefined;
-    const keys = getStringValues(prop.type);
-    if (keys.length === 0) {
-        diagnostics.push(createDiagnostic({
-            code: "invalid-discriminator-value",
-            format: { kind: prop.type.kind },
-            target: prop,
-        }));
-    }
-    return keys;
-}
-function getStringValues(type) {
-    switch (type.kind) {
-        case "String":
-            return [type.value];
-        case "Union":
-            return [...type.variants.values()].flatMap((x) => getStringValues(x.type)).filter(isDefined);
-        case "EnumMember":
-            return typeof type.value !== "number" ? [type.value ?? type.name] : [];
-        case "UnionVariant":
-            return getStringValues(type.type);
-        default:
-            return [];
-    }
-}
-function getStringValue(type) {
-    switch (type.kind) {
-        case "String":
-            return type.value;
-        case "EnumMember":
-            return typeof type.value !== "number" ? (type.value ?? type.name) : undefined;
-        default:
-            return undefined;
-    }
-}
-
 /**
  * Get a plausible name for the given type.
  * @experimental
@@ -31271,15 +31318,12 @@ defineKit({
                         instantiationParameters: type.instantiationParameters
                             ? [...type.instantiationParameters]
                             : undefined,
-                        // eslint-disable-next-line @typescript-eslint/no-deprecated
-                        projections: [...type.projections],
                         models: copyMap(type.models),
                         decoratorDeclarations: copyMap(type.decoratorDeclarations),
                         enums: copyMap(type.enums),
                         unions: copyMap(type.unions),
                         operations: copyMap(type.operations),
                         interfaces: copyMap(type.interfaces),
-                        functionDeclarations: copyMap(type.functionDeclarations),
                         namespaces: copyMap(type.namespaces),
                         scalars: copyMap(type.scalars),
                     });
@@ -31318,11 +31362,18 @@ defineKit({
             return getPlausibleName(type);
         },
         getDiscriminator(type) {
-            return getDiscriminator(this.program, type);
-        },
-        getDiscriminatedUnion(type) {
-            const [union] = getDiscriminatedUnion(this.program, type);
-            return union;
+            let discriminator;
+            if ($$1.model.is(type)) {
+                discriminator = getDiscriminator(this.program, type);
+            }
+            else {
+                const unionDiscriminator = ignoreDiagnostics(getDiscriminatedUnion(this.program, type));
+                const propertyName = unionDiscriminator?.options.discriminatorPropertyName;
+                if (propertyName) {
+                    discriminator = { propertyName };
+                }
+            }
+            return discriminator;
         },
         maxValue(type) {
             return getMaxValue(this.program, type);
@@ -31446,6 +31497,9 @@ defineKit({
         isExpression(type) {
             return type.name === undefined || type.name === "";
         },
+        getDiscriminatedUnion(type) {
+            return ignoreDiagnostics(getDiscriminatedUnion(this.program, type));
+        },
     },
 });
 
@@ -31842,14 +31896,6 @@ class Realm {
 }
 _a = Realm;
 
-function getLocationContext(program, type) {
-    const sourceLocation = getSourceLocation(type);
-    if (sourceLocation.isSynthetic) {
-        return { type: "synthetic" };
-    }
-    return program.getSourceFileLocationContext(sourceLocation.file);
-}
-
 /**
  * The fixed set of options for each of the kinds of delimited lists in TypeSpec.
  */
@@ -31968,18 +32014,6 @@ var ListKind;
         close: Token.CloseParen,
         invalidAnnotationTarget: "expression",
     };
-    ListKind.ProjectionExpression = {
-        ...ExpresionsBase,
-        allowEmpty: true,
-        open: Token.OpenParen,
-        close: Token.CloseParen,
-    };
-    ListKind.ProjectionParameter = {
-        ...ExpresionsBase,
-        allowEmpty: true,
-        open: Token.OpenParen,
-        close: Token.CloseParen,
-    };
 })(ListKind || (ListKind = {}));
 
 /**
@@ -32011,7 +32045,6 @@ var ListKind;
     ],
 });
 
-/* eslint-disable @typescript-eslint/no-deprecated */
 var Related;
 (function (Related) {
     Related[Related["false"] = 0] = "false";
@@ -32020,7 +32053,6 @@ var Related;
 })(Related || (Related = {}));
 // #endregion
 
-/* eslint-disable @typescript-eslint/no-deprecated */
 /**
  * Find all named models that could have been the source of the given
  * property. This includes the named parents of all property sources in a
@@ -33521,11 +33553,6 @@ var CommentCheckFlags;
     CommentCheckFlags[CommentCheckFlags["Last"] = 256] = "Last";
 })(CommentCheckFlags || (CommentCheckFlags = {}));
 
-const globalLibraryUrlsLoadedSym = Symbol.for("TYPESPEC_LIBRARY_URLS_LOADED");
-if (globalThis[globalLibraryUrlsLoadedSym] === undefined) {
-    globalThis[globalLibraryUrlsLoadedSym] = new Set();
-}
-
 // prettier-ignore
 var UsageFlags;
 (function (UsageFlags) {
@@ -33534,8 +33561,25 @@ var UsageFlags;
     UsageFlags[UsageFlags["Output"] = 4] = "Output";
 })(UsageFlags || (UsageFlags = {}));
 
+const globalLibraryUrlsLoadedSym = Symbol.for("TYPESPEC_LIBRARY_URLS_LOADED");
+if (globalThis[globalLibraryUrlsLoadedSym] === undefined) {
+    globalThis[globalLibraryUrlsLoadedSym] = new Set();
+}
+
 const CompilerPackageRoot = undefined;
 
+let manifest;
+try {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    manifest = (await import('../manifest-CrFWPTea.js')).default;
+}
+catch {
+    const name = "../dist/manifest.js";
+    manifest = (await import(/* @vite-ignore */ /* webpackIgnore: true */ name)).default;
+}
+manifest.version;
+
 var main$4 = {};
 
 var api$2 = {};
@@ -44671,8 +44715,7 @@ const TypeConfig = {
     operations: "nested",
     unions: "nested",
     enums: "nested",
-    decoratorDeclarations: "nested",
-    functionDeclarations: "nested"
+    decoratorDeclarations: "nested"
   },
   Interface: {
     operations: "nested",
@@ -44757,10 +44800,7 @@ const TypeConfig = {
     default: "value"
   },
   // Don't want to expose those for now
-  Function: null,
-  Object: null,
-  Intrinsic: null,
-  Projection: null
+  Intrinsic: null
 };
 const CommonPropsConfig = {
   namespace: "parent"
@@ -44776,11 +44816,7 @@ const HiddenProps = [
   "templateMapper",
   "instantiationParameters",
   "decorators",
-  "projectionBase",
-  "projectionsByName",
-  "projectionSource",
   "projector",
-  "projections",
   "isFinished"
 ];
 new Set(HiddenProps);
@@ -44839,7 +44875,7 @@ function computeReferences(node) {
   return { pathToNode, typeToPath };
 }
 function computeTree(program) {
-  const root = program.checker.getGlobalNamespaceType();
+  const root = program.getGlobalNamespaceType();
   const namespaces = expandNamespaces(root);
   return {
     kind: "list",