@jigging/jig 0.1.0-alpha.2 → 0.1.0-alpha.20

package/libexec/authoring/node_modules/@typespec/compiler/dist/src/core/messages.d.ts

@@ -0,0 +1,3560 @@
+import type { TypeOfDiagnostics } from "./types.js";
+declare const diagnostics: {
+    /**
+     * Scanner errors.
+     */
+    readonly "digit-expected": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Digit expected.";
+        };
+    };
+    readonly "hex-digit-expected": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Hexadecimal digit expected.";
+        };
+    };
+    readonly "binary-digit-expected": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Binary digit expected.";
+        };
+    };
+    readonly unterminated: {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["token"]>;
+        };
+    };
+    readonly "creating-file": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["filename", "error"]>;
+        };
+    };
+    readonly "invalid-escape-sequence": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Invalid escape sequence.";
+        };
+    };
+    readonly "no-new-line-start-triple-quote": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "String content in triple quotes must begin on a new line.";
+        };
+    };
+    readonly "no-new-line-end-triple-quote": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Closing triple quotes must begin on a new line.";
+        };
+    };
+    readonly "triple-quote-indent": {
+        readonly severity: "error";
+        readonly description: "Report when a triple-quoted string has lines with less indentation as the closing triple quotes.";
+        readonly url: "https://typespec.io/docs/standard-library/diags/triple-quote-indent";
+        readonly messages: {
+            readonly default: "All lines in triple-quoted string lines must have the same indentation as closing triple quotes.";
+        };
+    };
+    readonly "invalid-character": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Invalid character.";
+        };
+    };
+    /**
+     * Utils
+     */
+    readonly "file-not-found": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["path"]>;
+        };
+    };
+    readonly "file-load": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["message"]>;
+        };
+    };
+    /**
+     * Init templates
+     */
+    readonly "init-template-invalid-json": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["url", "message"]>;
+        };
+    };
+    readonly "init-template-download-failed": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["url", "message"]>;
+        };
+    };
+    /**
+     * Parser errors.
+     */
+    readonly "multiple-blockless-namespace": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Cannot use multiple blockless namespaces.";
+        };
+    };
+    readonly "blockless-namespace-first": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Blockless namespaces can't follow other declarations.";
+            readonly topLevel: "Blockless namespace can only be top-level.";
+        };
+    };
+    readonly "import-first": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Imports must come prior to namespaces or other declarations.";
+            readonly topLevel: "Imports must be top-level and come prior to namespaces or other declarations.";
+        };
+    };
+    readonly "duplicate-import": {
+        readonly severity: "warning";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["importPath"]>;
+        };
+    };
+    readonly "self-import": {
+        readonly severity: "warning";
+        readonly messages: {
+            readonly default: "A file cannot import itself.";
+        };
+    };
+    readonly "token-expected": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["token"]>;
+            readonly unexpected: import("./types.js").CallableMessage<["token"]>;
+            readonly numericOrStringLiteral: "Expected numeric or string literal.";
+            readonly identifier: "Identifier expected.";
+            readonly expression: "Expression expected.";
+            readonly statement: "Statement expected.";
+            readonly property: "Property expected.";
+            readonly enumMember: "Enum member expected.";
+            readonly typeofTarget: "Typeof expects a value literal or value reference.";
+        };
+    };
+    readonly "unknown-directive": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["id"]>;
+        };
+    };
+    readonly "augment-decorator-target": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Augment decorator first argument must be a type reference.";
+            readonly noInstance: "Cannot reference template instances.";
+            readonly noModelExpression: "Cannot augment model expressions.";
+            readonly noUnionExpression: "Cannot augment union expressions.";
+        };
+    };
+    readonly "duplicate-decorator": {
+        readonly severity: "warning";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["decoratorName"]>;
+        };
+    };
+    readonly "decorator-conflict": {
+        readonly severity: "warning";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["decoratorName", "otherDecoratorName"]>;
+        };
+    };
+    readonly "reserved-identifier": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Keyword cannot be used as identifier.";
+            readonly future: import("./types.js").CallableMessage<["name"]>;
+        };
+    };
+    readonly "invalid-directive-location": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["nodeName"]>;
+        };
+    };
+    readonly "invalid-decorator-location": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["nodeName"]>;
+        };
+    };
+    readonly "default-required": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Required template parameters must not follow optional template parameters";
+        };
+    };
+    readonly "invalid-template-argument-name": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Template parameter argument names must be valid, bare identifiers.";
+        };
+    };
+    readonly "invalid-template-default": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Template parameter defaults can only reference previously declared type parameters.";
+        };
+    };
+    readonly "required-parameter-first": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "A required parameter cannot follow an optional parameter.";
+        };
+    };
+    readonly "rest-parameter-last": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "A rest parameter must be last in a parameter list.";
+        };
+    };
+    readonly "rest-parameter-required": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "A rest parameter cannot be optional.";
+        };
+    };
+    /**
+     * Parser doc comment warnings.
+     * Design goal: Malformed doc comments should only produce warnings, not errors.
+     */
+    readonly "doc-invalid-identifier": {
+        readonly severity: "warning";
+        readonly messages: {
+            readonly default: "Invalid identifier.";
+            readonly tag: "Invalid tag name. Use backticks around code if this was not meant to be a tag.";
+            readonly param: "Invalid parameter name.";
+            readonly prop: "Invalid property name.";
+            readonly templateParam: "Invalid template parameter name.";
+        };
+    };
+    /**
+     * Checker
+     */
+    readonly "experimental-feature": {
+        readonly severity: "warning";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["feature"]>;
+            readonly functionDeclarations: "Function declarations are an experimental feature that may change in the future. Use with caution and consider providing feedback to the TypeSpec team.";
+        };
+    };
+    readonly "union-extends-disabled": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Union `extends` clauses require the 'union-extends' feature to be enabled. Add 'union-extends' to the 'features' list in your tspconfig.yaml.";
+        };
+    };
+    readonly "auto-decorator-disabled": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Auto decorator declarations require the 'auto-decorators' feature to be enabled. Add 'auto-decorators' to the 'features' list in your tspconfig.yaml.";
+        };
+    };
+    readonly "using-invalid-ref": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Using must refer to a namespace";
+        };
+    };
+    readonly "invalid-type-ref": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Invalid type reference";
+            readonly decorator: "Can't put a decorator in a type";
+            readonly function: "Can't use a function as a type";
+        };
+    };
+    readonly "invalid-template-args": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Invalid template arguments.";
+            readonly notTemplate: "Can't pass template arguments to non-templated type";
+            readonly tooMany: "Too many template arguments provided.";
+            readonly unknownName: import("./types.js").CallableMessage<["name"]>;
+            readonly positionalAfterNamed: "Positional template arguments cannot follow named arguments in the same argument list.";
+            readonly missing: import("./types.js").CallableMessage<["name"]>;
+            readonly specifiedAgain: import("./types.js").CallableMessage<["name"]>;
+        };
+    };
+    readonly "intersect-non-model": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Cannot intersect non-model types (including union types).";
+        };
+    };
+    readonly "intersect-invalid-index": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Cannot intersect incompatible models.";
+            readonly never: "Cannot intersect a model that cannot hold properties.";
+            readonly array: "Cannot intersect an array model.";
+        };
+    };
+    readonly "incompatible-indexer": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["message"]>;
+        };
+    };
+    readonly "no-array-properties": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Array models cannot have any properties.";
+        };
+    };
+    readonly "intersect-duplicate-property": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["propName"]>;
+        };
+    };
+    readonly "invalid-decorator": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["id"]>;
+        };
+    };
+    readonly "invalid-ref": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["id"]>;
+            readonly identifier: import("./types.js").CallableMessage<["id"]>;
+            readonly decorator: import("./types.js").CallableMessage<["id"]>;
+            readonly inDecorator: import("./types.js").CallableMessage<["id"]>;
+            readonly underNamespace: import("./types.js").CallableMessage<["namespace", "id"]>;
+            readonly member: import("./types.js").CallableMessage<["kind", "id"]>;
+            readonly metaProperty: import("./types.js").CallableMessage<["kind", "id"]>;
+            readonly node: import("./types.js").CallableMessage<["id", "nodeName"]>;
+            readonly internal: import("./types.js").CallableMessage<["id"]>;
+        };
+    };
+    readonly "duplicate-property": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["propName"]>;
+            readonly withModel: import("./types.js").CallableMessage<["modelName", "propName"]>;
+        };
+    };
+    readonly "override-property-mismatch": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["propName", "propType", "parentType"]>;
+            readonly disallowedOptionalOverride: import("./types.js").CallableMessage<["propName"]>;
+        };
+    };
+    readonly "extend-scalar": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Scalar must extend other scalars.";
+        };
+    };
+    readonly "extend-model": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Models must extend other models.";
+            readonly modelExpression: "Models cannot extend model expressions.";
+        };
+    };
+    readonly "extend-union": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Union `extends` must specify a model, scalar, enum, or union.";
+            readonly modelExpression: "Unions cannot extend model expressions.";
+        };
+    };
+    readonly "is-model": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Model `is` must specify another model.";
+            readonly modelExpression: "Model `is` cannot specify a model expression.";
+        };
+    };
+    readonly "is-operation": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Operation can only reuse the signature of another operation.";
+        };
+    };
+    readonly "spread-model": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Cannot spread properties of non-model type.";
+            readonly neverIndex: "Cannot spread type because it cannot hold properties.";
+            readonly selfSpread: "Cannot spread type within its own declaration.";
+        };
+    };
+    readonly "unsupported-default": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["type"]>;
+        };
+    };
+    readonly "spread-object": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Cannot spread properties of non-object type.";
+        };
+    };
+    readonly "expect-value": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["name"]>;
+            readonly model: import("./types.js").CallableMessage<["name"]>;
+            readonly modelExpression: "Is a model expression type, but is being used as a value here. Use #{} to create an object value.";
+            readonly tuple: "Is a tuple type, but is being used as a value here. Use #[] to create an array value.";
+            readonly templateConstraint: import("./types.js").CallableMessage<["name"]>;
+            readonly functionReturn: import("./types.js").CallableMessage<[]>;
+        };
+    };
+    readonly "non-callable": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["type"]>;
+            readonly templateParameter: import("./types.js").CallableMessage<["name", "constraint"]>;
+        };
+    };
+    readonly "named-init-required": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<[]>;
+        };
+    };
+    readonly "invalid-primitive-init": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Instantiating scalar deriving from 'string', 'numeric' or 'boolean' can only take a single argument.";
+            readonly invalidArg: import("./types.js").CallableMessage<["expected", "actual"]>;
+        };
+    };
+    readonly "ambiguous-scalar-type": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["value", "types", "example", "value"]>;
+        };
+    };
+    readonly unassignable: {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["sourceType", "targetType"]>;
+        };
+    };
+    readonly "property-unassignable": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["propName"]>;
+        };
+    };
+    readonly "property-required": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["propName", "targetType"]>;
+        };
+    };
+    readonly "parameter-required": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["paramName"]>;
+            readonly missing: import("./types.js").CallableMessage<["paramName"]>;
+            readonly "rest-to-required": import("./types.js").CallableMessage<["paramName"]>;
+        };
+    };
+    readonly "value-in-type": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "A value cannot be used as a type.";
+            readonly referenceTemplate: "Template parameter can be passed values but is used as a type.";
+            readonly noTemplateConstraint: "Template parameter has no constraint but a value is passed. Add `extends valueof unknown` to accept any value.";
+        };
+    };
+    readonly "no-prop": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["propName"]>;
+        };
+    };
+    readonly "missing-index": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["indexType", "sourceType"]>;
+        };
+    };
+    readonly "missing-property": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["propertyName", "sourceType", "targetType"]>;
+        };
+    };
+    readonly "unexpected-property": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["propertyName", "type"]>;
+        };
+    };
+    readonly "extends-interface": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Interfaces can only extend other interfaces";
+        };
+    };
+    readonly "extends-interface-duplicate": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["name"]>;
+        };
+    };
+    readonly "interface-duplicate": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["name"]>;
+        };
+    };
+    readonly "union-duplicate": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["name"]>;
+        };
+    };
+    readonly "enum-member-duplicate": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["name"]>;
+        };
+    };
+    readonly "constructor-duplicate": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["name"]>;
+        };
+    };
+    readonly "spread-enum": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Cannot spread members of non-enum type.";
+        };
+    };
+    readonly "decorator-fail": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["decoratorName", "error"]>;
+        };
+    };
+    readonly "rest-parameter-array": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "A rest parameter must be of an array type.";
+        };
+    };
+    readonly "invalid-modifier": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["modifier"]>;
+            readonly "missing-required": import("./types.js").CallableMessage<["nodeKind", "modifier"]>;
+            readonly "missing-required-one-of": import("./types.js").CallableMessage<["nodeKind", "modifiers"]>;
+            readonly "mutually-exclusive": import("./types.js").CallableMessage<["modifierA", "modifierB"]>;
+            readonly "not-allowed": import("./types.js").CallableMessage<["modifier", "nodeKind"]>;
+        };
+    };
+    readonly "function-return": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Function implementation returned an invalid result.";
+            readonly "invalid-value": import("./types.js").CallableMessage<["value"]>;
+            readonly unassignable: import("./types.js").CallableMessage<["name", "entityKind", "return", "type"]>;
+        };
+    };
+    readonly "fn-in-union-expression": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Function types in anonymous union expressions must be parenthesized.";
+        };
+    };
+    readonly "missing-implementation": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Extern declaration must have an implementation in JS file.";
+        };
+    };
+    readonly "missing-extern-declaration": {
+        readonly severity: "error";
+        readonly description: "Report when a function is registered in $functions in a JS file but has no corresponding `extern fn` declaration in TypeSpec.";
+        readonly url: "https://typespec.io/docs/standard-library/diags/missing-extern-declaration";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["name"]>;
+        };
+    };
+    readonly "overload-same-parent": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Overload must be in the same interface or namespace.";
+        };
+    };
+    readonly shadow: {
+        readonly severity: "warning";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["name"]>;
+        };
+    };
+    readonly "invalid-deprecation-argument": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["kind"]>;
+            readonly missing: "#deprecation directive is expecting a message argument but none was provided.";
+        };
+    };
+    readonly "duplicate-deprecation": {
+        readonly severity: "warning";
+        readonly messages: {
+            readonly default: "The #deprecated directive cannot be used more than once on the same declaration.";
+        };
+    };
+    /**
+     * Configuration
+     */
+    readonly "config-invalid-argument": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["name"]>;
+        };
+    };
+    readonly "config-circular-variable": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["name"]>;
+        };
+    };
+    readonly "config-path-absolute": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["path"]>;
+        };
+    };
+    readonly "config-invalid-name": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["name"]>;
+        };
+    };
+    readonly "path-unix-style": {
+        readonly severity: "warning";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<[]>;
+        };
+    };
+    readonly "config-path-not-found": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["path"]>;
+        };
+    };
+    readonly "config-project-kind-filename": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["filename"]>;
+        };
+    };
+    readonly "config-project-only-option": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["option"]>;
+        };
+    };
+    readonly "config-unknown-feature": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["feature"]>;
+        };
+    };
+    readonly "config-project-not-as-cli-config": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "`--config` cannot point to a project config (with `kind: project`). Use a non-project build config that `extends` the project config instead.";
+        };
+    };
+    /**
+     * Program
+     */
+    readonly "dynamic-import": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Dynamically generated TypeSpec cannot have imports";
+        };
+    };
+    readonly "invalid-import": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Import paths must reference either a directory, a .tsp file, or .js file";
+        };
+    };
+    readonly "invalid-main": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Main file must either be a .tsp file or a .js file.";
+        };
+    };
+    readonly "import-not-found": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["path"]>;
+        };
+    };
+    readonly "library-invalid": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["path", "message"]>;
+        };
+    };
+    readonly "incompatible-library": {
+        readonly severity: "warning";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["name", "versionMap"]>;
+        };
+    };
+    readonly "compiler-version-mismatch": {
+        readonly severity: "warning";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["basedir", "basedir", "betterTypeSpecServerPath", "expected", "actual"]>;
+        };
+    };
+    readonly "duplicate-symbol": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["name"]>;
+        };
+    };
+    readonly "duplicate-suppression": {
+        readonly severity: "warning";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["code"]>;
+        };
+    };
+    readonly "ambiguous-short-name": {
+        readonly severity: "warning";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["shortName", "candidates"]>;
+        };
+    };
+    readonly "decorator-decl-target": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "dec must have at least one parameter.";
+            readonly required: "dec first parameter must be required.";
+        };
+    };
+    readonly "mixed-string-template": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "String template is interpolating values and types. It must be either all values to produce a string value or or all types for string template type.";
+        };
+    };
+    readonly "non-literal-string-template": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Value interpolated in this string template cannot be converted to a string. Only literal types can be automatically interpolated.";
+        };
+    };
+    /**
+     * Binder
+     */
+    readonly "ambiguous-symbol": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["name", "duplicateNames", "duplicateNames"]>;
+        };
+    };
+    readonly "duplicate-using": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["usingName"]>;
+        };
+    };
+    /**
+     * Library
+     */
+    readonly "on-validate-fail": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["error"]>;
+        };
+    };
+    readonly "emitter-not-found": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["emitterPackage", "emitterPackage"]>;
+        };
+    };
+    readonly "invalid-emitter": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["emitterPackage"]>;
+        };
+    };
+    readonly "js-error": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["specifier", "error"]>;
+        };
+    };
+    readonly "missing-import": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["emitterName", "requiredImport", "requiredImport"]>;
+        };
+    };
+    /**
+     * Linter
+     */
+    readonly "invalid-rule-ref": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["ref"]>;
+        };
+    };
+    readonly "unknown-rule": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["ruleName", "libraryName"]>;
+        };
+    };
+    readonly "unknown-rule-set": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["ruleSetName", "libraryName"]>;
+        };
+    };
+    readonly "rule-enabled-disabled": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["ruleName"]>;
+        };
+    };
+    readonly "invalid-rule-options": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["ruleName", "details"]>;
+        };
+    };
+    readonly "circular-ruleset-file": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["path"]>;
+        };
+    };
+    readonly "ruleset-file-in-library": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["ruleSetName", "ref"]>;
+        };
+    };
+    /**
+     * Formatter
+     */
+    readonly "format-failed": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["file", "details"]>;
+        };
+    };
+    /**
+     * Decorator
+     */
+    readonly "invalid-pattern-regex": {
+        readonly severity: "warning";
+        readonly messages: {
+            readonly default: "@pattern decorator expects a valid regular expression pattern.";
+        };
+    };
+    readonly "decorator-wrong-target": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["decorator", "to"]>;
+            readonly withExpected: import("./types.js").CallableMessage<["decorator", "to", "expected"]>;
+        };
+    };
+    readonly "invalid-argument": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["value", "expected"]>;
+        };
+    };
+    readonly "invalid-argument-count": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["expected", "actual"]>;
+            readonly atLeast: import("./types.js").CallableMessage<["expected", "actual"]>;
+        };
+    };
+    readonly "known-values-invalid-enum": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["member", "type"]>;
+        };
+    };
+    readonly "invalid-value": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["kind"]>;
+            readonly atPath: import("./types.js").CallableMessage<["kind", "path"]>;
+        };
+    };
+    readonly deprecated: {
+        readonly severity: "warning";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["message"]>;
+        };
+    };
+    readonly "no-optional-key": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["propertyName"]>;
+        };
+    };
+    readonly "invalid-discriminated-union": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "";
+            readonly noAnonVariants: "Unions with anonymous variants cannot be discriminated";
+        };
+    };
+    readonly "invalid-discriminated-union-variant": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["name"]>;
+            readonly noEnvelopeModel: import("./types.js").CallableMessage<["name"]>;
+            readonly discriminantMismatch: import("./types.js").CallableMessage<["name", "discriminant", "propertyValue", "variantName"]>;
+            readonly duplicateDefaultVariant: import("./types.js").CallableMessage<["unionName"]>;
+            readonly noDiscriminant: import("./types.js").CallableMessage<["name", "discriminant"]>;
+            readonly wrongDiscriminantType: import("./types.js").CallableMessage<["name", "discriminant"]>;
+        };
+    };
+    readonly "missing-discriminator-property": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["discriminator", "discriminator"]>;
+        };
+    };
+    readonly "invalid-discriminator-value": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["kind"]>;
+            readonly required: "The discriminator property must be a required property.";
+            readonly duplicate: import("./types.js").CallableMessage<["discriminator"]>;
+        };
+    };
+    readonly "invalid-encode": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Invalid encoding";
+            readonly wrongType: import("./types.js").CallableMessage<["encoding", "type", "expected"]>;
+            readonly wrongEncodingType: import("./types.js").CallableMessage<["encoding", "type", "expected", "actual"]>;
+            readonly wrongNumericEncodingType: import("./types.js").CallableMessage<["encoding", "type", "expected", "actual", "expected", "encoding"]>;
+            readonly firstArg: "First argument of \"@encode\" must be the encoding name or the string type when encoding numeric or boolean types.";
+        };
+    };
+    readonly "invalid-mime-type": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["mimeType"]>;
+        };
+    };
+    readonly "no-mime-type-suffix": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["mimeType", "suffix"]>;
+        };
+    };
+    readonly "encoded-name-conflict": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["name", "mimeType"]>;
+            readonly duplicate: import("./types.js").CallableMessage<["name", "mimeType"]>;
+        };
+    };
+    readonly "incompatible-paging-props": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["kinds"]>;
+        };
+    };
+    readonly "invalid-paging-prop": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["kind"]>;
+            readonly input: import("./types.js").CallableMessage<["kind"]>;
+            readonly output: import("./types.js").CallableMessage<["kind"]>;
+        };
+    };
+    readonly "duplicate-paging-prop": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["kind", "operationName"]>;
+        };
+    };
+    readonly "missing-paging-items": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["operationName"]>;
+        };
+    };
+    /**
+     * Service
+     */
+    readonly "service-decorator-duplicate": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "@service can only be set once per TypeSpec document.";
+        };
+    };
+    readonly "list-type-not-model": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "@list decorator's parameter must be a model type.";
+        };
+    };
+    readonly "invalid-range": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["start", "end"]>;
+        };
+    };
+    /**
+     * Mutator
+     */
+    readonly "add-response": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Cannot add a response to anything except an operation statement.";
+        };
+    };
+    readonly "add-parameter": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Cannot add a parameter to anything except an operation statement.";
+        };
+    };
+    readonly "add-model-property": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Cannot add a model property to anything except a model statement.";
+        };
+    };
+    readonly "add-model-property-fail": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["propertyName", "propertyTypeName"]>;
+        };
+    };
+    readonly "add-response-type": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["responseTypeName", "operationName"]>;
+        };
+    };
+    readonly "circular-base-type": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["typeName"]>;
+        };
+    };
+    readonly "circular-constraint": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["typeName"]>;
+        };
+    };
+    readonly "circular-op-signature": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["typeName"]>;
+        };
+    };
+    readonly "circular-alias-type": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["typeName"]>;
+        };
+    };
+    readonly "circular-const": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["name"]>;
+        };
+    };
+    readonly "circular-prop": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["propName"]>;
+        };
+    };
+    readonly "conflict-marker": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Conflict marker encountered.";
+        };
+    };
+    readonly "visibility-sealed": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["propName"]>;
+        };
+    };
+    readonly "default-visibility-not-member": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "The default visibility modifiers of a class must be members of the class enum.";
+        };
+    };
+    readonly "operation-visibility-constraint-empty": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Operation visibility constraints with no arguments are not allowed.";
+            readonly returnType: "Return type visibility constraints with no arguments are not allowed.";
+            readonly parameter: "Parameter visibility constraints with no arguments are not allowed. To disable effective PATCH optionality, use @patch(#{ implicitOptionality: false }) instead.";
+        };
+    };
+    readonly "no-compatible-vs-installed": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "No compatible version of Visual Studio found.";
+        };
+    };
+    readonly "vs-extension-windows-only": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Visual Studio extension is not supported on non-Windows.";
+        };
+    };
+    readonly "vsix-download-failed": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["id", "message"]>;
+        };
+    };
+    readonly "vscode-in-path": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: "Couldn't find VS Code 'code' command in PATH. Make sure you have the VS Code executable added to the system PATH.";
+            readonly osx: "Couldn't find VS Code 'code' command in PATH. Make sure you have the VS Code executable added to the system PATH.\nSee instruction for Mac OS here https://code.visualstudio.com/docs/setup/mac";
+        };
+    };
+    readonly "invalid-option-flag": {
+        readonly severity: "error";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["value"]>;
+        };
+    };
+    readonly "cli-command-deprecated": {
+        readonly severity: "warning";
+        readonly messages: {
+            readonly default: import("./types.js").CallableMessage<["command", "docsUrl"]>;
+        };
+    };
+};
+export type CompilerDiagnostics = TypeOfDiagnostics<typeof diagnostics>;
+export declare const compilerDiagnosticCodes: Set<string>;
+export declare const createDiagnostic: <C extends "digit-expected" | "hex-digit-expected" | "binary-digit-expected" | "unterminated" | "creating-file" | "invalid-escape-sequence" | "no-new-line-start-triple-quote" | "no-new-line-end-triple-quote" | "triple-quote-indent" | "invalid-character" | "file-not-found" | "file-load" | "init-template-invalid-json" | "init-template-download-failed" | "multiple-blockless-namespace" | "blockless-namespace-first" | "import-first" | "duplicate-import" | "self-import" | "token-expected" | "unknown-directive" | "augment-decorator-target" | "duplicate-decorator" | "decorator-conflict" | "reserved-identifier" | "invalid-directive-location" | "invalid-decorator-location" | "default-required" | "invalid-template-argument-name" | "invalid-template-default" | "required-parameter-first" | "rest-parameter-last" | "rest-parameter-required" | "doc-invalid-identifier" | "experimental-feature" | "union-extends-disabled" | "auto-decorator-disabled" | "using-invalid-ref" | "invalid-type-ref" | "invalid-template-args" | "intersect-non-model" | "intersect-invalid-index" | "incompatible-indexer" | "no-array-properties" | "intersect-duplicate-property" | "invalid-decorator" | "invalid-ref" | "duplicate-property" | "override-property-mismatch" | "extend-scalar" | "extend-model" | "extend-union" | "is-model" | "is-operation" | "spread-model" | "unsupported-default" | "spread-object" | "expect-value" | "non-callable" | "named-init-required" | "invalid-primitive-init" | "ambiguous-scalar-type" | "unassignable" | "property-unassignable" | "property-required" | "parameter-required" | "value-in-type" | "no-prop" | "missing-index" | "missing-property" | "unexpected-property" | "extends-interface" | "extends-interface-duplicate" | "interface-duplicate" | "union-duplicate" | "enum-member-duplicate" | "constructor-duplicate" | "spread-enum" | "decorator-fail" | "rest-parameter-array" | "invalid-modifier" | "function-return" | "invalid-value" | "fn-in-union-expression" | "missing-implementation" | "missing-extern-declaration" | "overload-same-parent" | "shadow" | "invalid-deprecation-argument" | "duplicate-deprecation" | "config-invalid-argument" | "config-circular-variable" | "config-path-absolute" | "config-invalid-name" | "path-unix-style" | "config-path-not-found" | "config-project-kind-filename" | "config-project-only-option" | "config-unknown-feature" | "config-project-not-as-cli-config" | "dynamic-import" | "invalid-import" | "invalid-main" | "import-not-found" | "library-invalid" | "incompatible-library" | "compiler-version-mismatch" | "duplicate-symbol" | "duplicate-suppression" | "ambiguous-short-name" | "decorator-decl-target" | "mixed-string-template" | "non-literal-string-template" | "ambiguous-symbol" | "duplicate-using" | "on-validate-fail" | "emitter-not-found" | "invalid-emitter" | "js-error" | "missing-import" | "invalid-rule-ref" | "unknown-rule" | "unknown-rule-set" | "rule-enabled-disabled" | "invalid-rule-options" | "circular-ruleset-file" | "ruleset-file-in-library" | "format-failed" | "invalid-pattern-regex" | "decorator-wrong-target" | "invalid-argument" | "invalid-argument-count" | "known-values-invalid-enum" | "deprecated" | "no-optional-key" | "invalid-discriminated-union" | "invalid-discriminated-union-variant" | "missing-discriminator-property" | "invalid-discriminator-value" | "invalid-encode" | "invalid-mime-type" | "no-mime-type-suffix" | "encoded-name-conflict" | "incompatible-paging-props" | "invalid-paging-prop" | "duplicate-paging-prop" | "missing-paging-items" | "service-decorator-duplicate" | "list-type-not-model" | "invalid-range" | "add-response" | "add-parameter" | "add-model-property" | "add-model-property-fail" | "add-response-type" | "circular-base-type" | "circular-constraint" | "circular-op-signature" | "circular-alias-type" | "circular-const" | "circular-prop" | "conflict-marker" | "visibility-sealed" | "default-visibility-not-member" | "operation-visibility-constraint-empty" | "no-compatible-vs-installed" | "vs-extension-windows-only" | "vsix-download-failed" | "vscode-in-path" | "invalid-option-flag" | "cli-command-deprecated", M extends keyof {
+    "digit-expected": {
+        readonly default: "Digit expected.";
+    };
+    "hex-digit-expected": {
+        readonly default: "Hexadecimal digit expected.";
+    };
+    "binary-digit-expected": {
+        readonly default: "Binary digit expected.";
+    };
+    unterminated: {
+        readonly default: import("./types.js").CallableMessage<["token"]>;
+    };
+    "creating-file": {
+        readonly default: import("./types.js").CallableMessage<["filename", "error"]>;
+    };
+    "invalid-escape-sequence": {
+        readonly default: "Invalid escape sequence.";
+    };
+    "no-new-line-start-triple-quote": {
+        readonly default: "String content in triple quotes must begin on a new line.";
+    };
+    "no-new-line-end-triple-quote": {
+        readonly default: "Closing triple quotes must begin on a new line.";
+    };
+    "triple-quote-indent": {
+        readonly default: "All lines in triple-quoted string lines must have the same indentation as closing triple quotes.";
+    };
+    "invalid-character": {
+        readonly default: "Invalid character.";
+    };
+    "file-not-found": {
+        readonly default: import("./types.js").CallableMessage<["path"]>;
+    };
+    "file-load": {
+        readonly default: import("./types.js").CallableMessage<["message"]>;
+    };
+    "init-template-invalid-json": {
+        readonly default: import("./types.js").CallableMessage<["url", "message"]>;
+    };
+    "init-template-download-failed": {
+        readonly default: import("./types.js").CallableMessage<["url", "message"]>;
+    };
+    "multiple-blockless-namespace": {
+        readonly default: "Cannot use multiple blockless namespaces.";
+    };
+    "blockless-namespace-first": {
+        readonly default: "Blockless namespaces can't follow other declarations.";
+        readonly topLevel: "Blockless namespace can only be top-level.";
+    };
+    "import-first": {
+        readonly default: "Imports must come prior to namespaces or other declarations.";
+        readonly topLevel: "Imports must be top-level and come prior to namespaces or other declarations.";
+    };
+    "duplicate-import": {
+        readonly default: import("./types.js").CallableMessage<["importPath"]>;
+    };
+    "self-import": {
+        readonly default: "A file cannot import itself.";
+    };
+    "token-expected": {
+        readonly default: import("./types.js").CallableMessage<["token"]>;
+        readonly unexpected: import("./types.js").CallableMessage<["token"]>;
+        readonly numericOrStringLiteral: "Expected numeric or string literal.";
+        readonly identifier: "Identifier expected.";
+        readonly expression: "Expression expected.";
+        readonly statement: "Statement expected.";
+        readonly property: "Property expected.";
+        readonly enumMember: "Enum member expected.";
+        readonly typeofTarget: "Typeof expects a value literal or value reference.";
+    };
+    "unknown-directive": {
+        readonly default: import("./types.js").CallableMessage<["id"]>;
+    };
+    "augment-decorator-target": {
+        readonly default: "Augment decorator first argument must be a type reference.";
+        readonly noInstance: "Cannot reference template instances.";
+        readonly noModelExpression: "Cannot augment model expressions.";
+        readonly noUnionExpression: "Cannot augment union expressions.";
+    };
+    "duplicate-decorator": {
+        readonly default: import("./types.js").CallableMessage<["decoratorName"]>;
+    };
+    "decorator-conflict": {
+        readonly default: import("./types.js").CallableMessage<["decoratorName", "otherDecoratorName"]>;
+    };
+    "reserved-identifier": {
+        readonly default: "Keyword cannot be used as identifier.";
+        readonly future: import("./types.js").CallableMessage<["name"]>;
+    };
+    "invalid-directive-location": {
+        readonly default: import("./types.js").CallableMessage<["nodeName"]>;
+    };
+    "invalid-decorator-location": {
+        readonly default: import("./types.js").CallableMessage<["nodeName"]>;
+    };
+    "default-required": {
+        readonly default: "Required template parameters must not follow optional template parameters";
+    };
+    "invalid-template-argument-name": {
+        readonly default: "Template parameter argument names must be valid, bare identifiers.";
+    };
+    "invalid-template-default": {
+        readonly default: "Template parameter defaults can only reference previously declared type parameters.";
+    };
+    "required-parameter-first": {
+        readonly default: "A required parameter cannot follow an optional parameter.";
+    };
+    "rest-parameter-last": {
+        readonly default: "A rest parameter must be last in a parameter list.";
+    };
+    "rest-parameter-required": {
+        readonly default: "A rest parameter cannot be optional.";
+    };
+    "doc-invalid-identifier": {
+        readonly default: "Invalid identifier.";
+        readonly tag: "Invalid tag name. Use backticks around code if this was not meant to be a tag.";
+        readonly param: "Invalid parameter name.";
+        readonly prop: "Invalid property name.";
+        readonly templateParam: "Invalid template parameter name.";
+    };
+    "experimental-feature": {
+        readonly default: import("./types.js").CallableMessage<["feature"]>;
+        readonly functionDeclarations: "Function declarations are an experimental feature that may change in the future. Use with caution and consider providing feedback to the TypeSpec team.";
+    };
+    "union-extends-disabled": {
+        readonly default: "Union `extends` clauses require the 'union-extends' feature to be enabled. Add 'union-extends' to the 'features' list in your tspconfig.yaml.";
+    };
+    "auto-decorator-disabled": {
+        readonly default: "Auto decorator declarations require the 'auto-decorators' feature to be enabled. Add 'auto-decorators' to the 'features' list in your tspconfig.yaml.";
+    };
+    "using-invalid-ref": {
+        readonly default: "Using must refer to a namespace";
+    };
+    "invalid-type-ref": {
+        readonly default: "Invalid type reference";
+        readonly decorator: "Can't put a decorator in a type";
+        readonly function: "Can't use a function as a type";
+    };
+    "invalid-template-args": {
+        readonly default: "Invalid template arguments.";
+        readonly notTemplate: "Can't pass template arguments to non-templated type";
+        readonly tooMany: "Too many template arguments provided.";
+        readonly unknownName: import("./types.js").CallableMessage<["name"]>;
+        readonly positionalAfterNamed: "Positional template arguments cannot follow named arguments in the same argument list.";
+        readonly missing: import("./types.js").CallableMessage<["name"]>;
+        readonly specifiedAgain: import("./types.js").CallableMessage<["name"]>;
+    };
+    "intersect-non-model": {
+        readonly default: "Cannot intersect non-model types (including union types).";
+    };
+    "intersect-invalid-index": {
+        readonly default: "Cannot intersect incompatible models.";
+        readonly never: "Cannot intersect a model that cannot hold properties.";
+        readonly array: "Cannot intersect an array model.";
+    };
+    "incompatible-indexer": {
+        readonly default: import("./types.js").CallableMessage<["message"]>;
+    };
+    "no-array-properties": {
+        readonly default: "Array models cannot have any properties.";
+    };
+    "intersect-duplicate-property": {
+        readonly default: import("./types.js").CallableMessage<["propName"]>;
+    };
+    "invalid-decorator": {
+        readonly default: import("./types.js").CallableMessage<["id"]>;
+    };
+    "invalid-ref": {
+        readonly default: import("./types.js").CallableMessage<["id"]>;
+        readonly identifier: import("./types.js").CallableMessage<["id"]>;
+        readonly decorator: import("./types.js").CallableMessage<["id"]>;
+        readonly inDecorator: import("./types.js").CallableMessage<["id"]>;
+        readonly underNamespace: import("./types.js").CallableMessage<["namespace", "id"]>;
+        readonly member: import("./types.js").CallableMessage<["kind", "id"]>;
+        readonly metaProperty: import("./types.js").CallableMessage<["kind", "id"]>;
+        readonly node: import("./types.js").CallableMessage<["id", "nodeName"]>;
+        readonly internal: import("./types.js").CallableMessage<["id"]>;
+    };
+    "duplicate-property": {
+        readonly default: import("./types.js").CallableMessage<["propName"]>;
+        readonly withModel: import("./types.js").CallableMessage<["modelName", "propName"]>;
+    };
+    "override-property-mismatch": {
+        readonly default: import("./types.js").CallableMessage<["propName", "propType", "parentType"]>;
+        readonly disallowedOptionalOverride: import("./types.js").CallableMessage<["propName"]>;
+    };
+    "extend-scalar": {
+        readonly default: "Scalar must extend other scalars.";
+    };
+    "extend-model": {
+        readonly default: "Models must extend other models.";
+        readonly modelExpression: "Models cannot extend model expressions.";
+    };
+    "extend-union": {
+        readonly default: "Union `extends` must specify a model, scalar, enum, or union.";
+        readonly modelExpression: "Unions cannot extend model expressions.";
+    };
+    "is-model": {
+        readonly default: "Model `is` must specify another model.";
+        readonly modelExpression: "Model `is` cannot specify a model expression.";
+    };
+    "is-operation": {
+        readonly default: "Operation can only reuse the signature of another operation.";
+    };
+    "spread-model": {
+        readonly default: "Cannot spread properties of non-model type.";
+        readonly neverIndex: "Cannot spread type because it cannot hold properties.";
+        readonly selfSpread: "Cannot spread type within its own declaration.";
+    };
+    "unsupported-default": {
+        readonly default: import("./types.js").CallableMessage<["type"]>;
+    };
+    "spread-object": {
+        readonly default: "Cannot spread properties of non-object type.";
+    };
+    "expect-value": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+        readonly model: import("./types.js").CallableMessage<["name"]>;
+        readonly modelExpression: "Is a model expression type, but is being used as a value here. Use #{} to create an object value.";
+        readonly tuple: "Is a tuple type, but is being used as a value here. Use #[] to create an array value.";
+        readonly templateConstraint: import("./types.js").CallableMessage<["name"]>;
+        readonly functionReturn: import("./types.js").CallableMessage<[]>;
+    };
+    "non-callable": {
+        readonly default: import("./types.js").CallableMessage<["type"]>;
+        readonly templateParameter: import("./types.js").CallableMessage<["name", "constraint"]>;
+    };
+    "named-init-required": {
+        readonly default: import("./types.js").CallableMessage<[]>;
+    };
+    "invalid-primitive-init": {
+        readonly default: "Instantiating scalar deriving from 'string', 'numeric' or 'boolean' can only take a single argument.";
+        readonly invalidArg: import("./types.js").CallableMessage<["expected", "actual"]>;
+    };
+    "ambiguous-scalar-type": {
+        readonly default: import("./types.js").CallableMessage<["value", "types", "example", "value"]>;
+    };
+    unassignable: {
+        readonly default: import("./types.js").CallableMessage<["sourceType", "targetType"]>;
+    };
+    "property-unassignable": {
+        readonly default: import("./types.js").CallableMessage<["propName"]>;
+    };
+    "property-required": {
+        readonly default: import("./types.js").CallableMessage<["propName", "targetType"]>;
+    };
+    "parameter-required": {
+        readonly default: import("./types.js").CallableMessage<["paramName"]>;
+        readonly missing: import("./types.js").CallableMessage<["paramName"]>;
+        readonly "rest-to-required": import("./types.js").CallableMessage<["paramName"]>;
+    };
+    "value-in-type": {
+        readonly default: "A value cannot be used as a type.";
+        readonly referenceTemplate: "Template parameter can be passed values but is used as a type.";
+        readonly noTemplateConstraint: "Template parameter has no constraint but a value is passed. Add `extends valueof unknown` to accept any value.";
+    };
+    "no-prop": {
+        readonly default: import("./types.js").CallableMessage<["propName"]>;
+    };
+    "missing-index": {
+        readonly default: import("./types.js").CallableMessage<["indexType", "sourceType"]>;
+    };
+    "missing-property": {
+        readonly default: import("./types.js").CallableMessage<["propertyName", "sourceType", "targetType"]>;
+    };
+    "unexpected-property": {
+        readonly default: import("./types.js").CallableMessage<["propertyName", "type"]>;
+    };
+    "extends-interface": {
+        readonly default: "Interfaces can only extend other interfaces";
+    };
+    "extends-interface-duplicate": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "interface-duplicate": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "union-duplicate": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "enum-member-duplicate": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "constructor-duplicate": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "spread-enum": {
+        readonly default: "Cannot spread members of non-enum type.";
+    };
+    "decorator-fail": {
+        readonly default: import("./types.js").CallableMessage<["decoratorName", "error"]>;
+    };
+    "rest-parameter-array": {
+        readonly default: "A rest parameter must be of an array type.";
+    };
+    "invalid-modifier": {
+        readonly default: import("./types.js").CallableMessage<["modifier"]>;
+        readonly "missing-required": import("./types.js").CallableMessage<["nodeKind", "modifier"]>;
+        readonly "missing-required-one-of": import("./types.js").CallableMessage<["nodeKind", "modifiers"]>;
+        readonly "mutually-exclusive": import("./types.js").CallableMessage<["modifierA", "modifierB"]>;
+        readonly "not-allowed": import("./types.js").CallableMessage<["modifier", "nodeKind"]>;
+    };
+    "function-return": {
+        readonly default: "Function implementation returned an invalid result.";
+        readonly "invalid-value": import("./types.js").CallableMessage<["value"]>;
+        readonly unassignable: import("./types.js").CallableMessage<["name", "entityKind", "return", "type"]>;
+    };
+    "fn-in-union-expression": {
+        readonly default: "Function types in anonymous union expressions must be parenthesized.";
+    };
+    "missing-implementation": {
+        readonly default: "Extern declaration must have an implementation in JS file.";
+    };
+    "missing-extern-declaration": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "overload-same-parent": {
+        readonly default: "Overload must be in the same interface or namespace.";
+    };
+    shadow: {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "invalid-deprecation-argument": {
+        readonly default: import("./types.js").CallableMessage<["kind"]>;
+        readonly missing: "#deprecation directive is expecting a message argument but none was provided.";
+    };
+    "duplicate-deprecation": {
+        readonly default: "The #deprecated directive cannot be used more than once on the same declaration.";
+    };
+    "config-invalid-argument": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "config-circular-variable": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "config-path-absolute": {
+        readonly default: import("./types.js").CallableMessage<["path"]>;
+    };
+    "config-invalid-name": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "path-unix-style": {
+        readonly default: import("./types.js").CallableMessage<[]>;
+    };
+    "config-path-not-found": {
+        readonly default: import("./types.js").CallableMessage<["path"]>;
+    };
+    "config-project-kind-filename": {
+        readonly default: import("./types.js").CallableMessage<["filename"]>;
+    };
+    "config-project-only-option": {
+        readonly default: import("./types.js").CallableMessage<["option"]>;
+    };
+    "config-unknown-feature": {
+        readonly default: import("./types.js").CallableMessage<["feature"]>;
+    };
+    "config-project-not-as-cli-config": {
+        readonly default: "`--config` cannot point to a project config (with `kind: project`). Use a non-project build config that `extends` the project config instead.";
+    };
+    "dynamic-import": {
+        readonly default: "Dynamically generated TypeSpec cannot have imports";
+    };
+    "invalid-import": {
+        readonly default: "Import paths must reference either a directory, a .tsp file, or .js file";
+    };
+    "invalid-main": {
+        readonly default: "Main file must either be a .tsp file or a .js file.";
+    };
+    "import-not-found": {
+        readonly default: import("./types.js").CallableMessage<["path"]>;
+    };
+    "library-invalid": {
+        readonly default: import("./types.js").CallableMessage<["path", "message"]>;
+    };
+    "incompatible-library": {
+        readonly default: import("./types.js").CallableMessage<["name", "versionMap"]>;
+    };
+    "compiler-version-mismatch": {
+        readonly default: import("./types.js").CallableMessage<["basedir", "basedir", "betterTypeSpecServerPath", "expected", "actual"]>;
+    };
+    "duplicate-symbol": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "duplicate-suppression": {
+        readonly default: import("./types.js").CallableMessage<["code"]>;
+    };
+    "ambiguous-short-name": {
+        readonly default: import("./types.js").CallableMessage<["shortName", "candidates"]>;
+    };
+    "decorator-decl-target": {
+        readonly default: "dec must have at least one parameter.";
+        readonly required: "dec first parameter must be required.";
+    };
+    "mixed-string-template": {
+        readonly default: "String template is interpolating values and types. It must be either all values to produce a string value or or all types for string template type.";
+    };
+    "non-literal-string-template": {
+        readonly default: "Value interpolated in this string template cannot be converted to a string. Only literal types can be automatically interpolated.";
+    };
+    "ambiguous-symbol": {
+        readonly default: import("./types.js").CallableMessage<["name", "duplicateNames", "duplicateNames"]>;
+    };
+    "duplicate-using": {
+        readonly default: import("./types.js").CallableMessage<["usingName"]>;
+    };
+    "on-validate-fail": {
+        readonly default: import("./types.js").CallableMessage<["error"]>;
+    };
+    "emitter-not-found": {
+        readonly default: import("./types.js").CallableMessage<["emitterPackage", "emitterPackage"]>;
+    };
+    "invalid-emitter": {
+        readonly default: import("./types.js").CallableMessage<["emitterPackage"]>;
+    };
+    "js-error": {
+        readonly default: import("./types.js").CallableMessage<["specifier", "error"]>;
+    };
+    "missing-import": {
+        readonly default: import("./types.js").CallableMessage<["emitterName", "requiredImport", "requiredImport"]>;
+    };
+    "invalid-rule-ref": {
+        readonly default: import("./types.js").CallableMessage<["ref"]>;
+    };
+    "unknown-rule": {
+        readonly default: import("./types.js").CallableMessage<["ruleName", "libraryName"]>;
+    };
+    "unknown-rule-set": {
+        readonly default: import("./types.js").CallableMessage<["ruleSetName", "libraryName"]>;
+    };
+    "rule-enabled-disabled": {
+        readonly default: import("./types.js").CallableMessage<["ruleName"]>;
+    };
+    "invalid-rule-options": {
+        readonly default: import("./types.js").CallableMessage<["ruleName", "details"]>;
+    };
+    "circular-ruleset-file": {
+        readonly default: import("./types.js").CallableMessage<["path"]>;
+    };
+    "ruleset-file-in-library": {
+        readonly default: import("./types.js").CallableMessage<["ruleSetName", "ref"]>;
+    };
+    "format-failed": {
+        readonly default: import("./types.js").CallableMessage<["file", "details"]>;
+    };
+    "invalid-pattern-regex": {
+        readonly default: "@pattern decorator expects a valid regular expression pattern.";
+    };
+    "decorator-wrong-target": {
+        readonly default: import("./types.js").CallableMessage<["decorator", "to"]>;
+        readonly withExpected: import("./types.js").CallableMessage<["decorator", "to", "expected"]>;
+    };
+    "invalid-argument": {
+        readonly default: import("./types.js").CallableMessage<["value", "expected"]>;
+    };
+    "invalid-argument-count": {
+        readonly default: import("./types.js").CallableMessage<["expected", "actual"]>;
+        readonly atLeast: import("./types.js").CallableMessage<["expected", "actual"]>;
+    };
+    "known-values-invalid-enum": {
+        readonly default: import("./types.js").CallableMessage<["member", "type"]>;
+    };
+    "invalid-value": {
+        readonly default: import("./types.js").CallableMessage<["kind"]>;
+        readonly atPath: import("./types.js").CallableMessage<["kind", "path"]>;
+    };
+    deprecated: {
+        readonly default: import("./types.js").CallableMessage<["message"]>;
+    };
+    "no-optional-key": {
+        readonly default: import("./types.js").CallableMessage<["propertyName"]>;
+    };
+    "invalid-discriminated-union": {
+        readonly default: "";
+        readonly noAnonVariants: "Unions with anonymous variants cannot be discriminated";
+    };
+    "invalid-discriminated-union-variant": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+        readonly noEnvelopeModel: import("./types.js").CallableMessage<["name"]>;
+        readonly discriminantMismatch: import("./types.js").CallableMessage<["name", "discriminant", "propertyValue", "variantName"]>;
+        readonly duplicateDefaultVariant: import("./types.js").CallableMessage<["unionName"]>;
+        readonly noDiscriminant: import("./types.js").CallableMessage<["name", "discriminant"]>;
+        readonly wrongDiscriminantType: import("./types.js").CallableMessage<["name", "discriminant"]>;
+    };
+    "missing-discriminator-property": {
+        readonly default: import("./types.js").CallableMessage<["discriminator", "discriminator"]>;
+    };
+    "invalid-discriminator-value": {
+        readonly default: import("./types.js").CallableMessage<["kind"]>;
+        readonly required: "The discriminator property must be a required property.";
+        readonly duplicate: import("./types.js").CallableMessage<["discriminator"]>;
+    };
+    "invalid-encode": {
+        readonly default: "Invalid encoding";
+        readonly wrongType: import("./types.js").CallableMessage<["encoding", "type", "expected"]>;
+        readonly wrongEncodingType: import("./types.js").CallableMessage<["encoding", "type", "expected", "actual"]>;
+        readonly wrongNumericEncodingType: import("./types.js").CallableMessage<["encoding", "type", "expected", "actual", "expected", "encoding"]>;
+        readonly firstArg: "First argument of \"@encode\" must be the encoding name or the string type when encoding numeric or boolean types.";
+    };
+    "invalid-mime-type": {
+        readonly default: import("./types.js").CallableMessage<["mimeType"]>;
+    };
+    "no-mime-type-suffix": {
+        readonly default: import("./types.js").CallableMessage<["mimeType", "suffix"]>;
+    };
+    "encoded-name-conflict": {
+        readonly default: import("./types.js").CallableMessage<["name", "mimeType"]>;
+        readonly duplicate: import("./types.js").CallableMessage<["name", "mimeType"]>;
+    };
+    "incompatible-paging-props": {
+        readonly default: import("./types.js").CallableMessage<["kinds"]>;
+    };
+    "invalid-paging-prop": {
+        readonly default: import("./types.js").CallableMessage<["kind"]>;
+        readonly input: import("./types.js").CallableMessage<["kind"]>;
+        readonly output: import("./types.js").CallableMessage<["kind"]>;
+    };
+    "duplicate-paging-prop": {
+        readonly default: import("./types.js").CallableMessage<["kind", "operationName"]>;
+    };
+    "missing-paging-items": {
+        readonly default: import("./types.js").CallableMessage<["operationName"]>;
+    };
+    "service-decorator-duplicate": {
+        readonly default: "@service can only be set once per TypeSpec document.";
+    };
+    "list-type-not-model": {
+        readonly default: "@list decorator's parameter must be a model type.";
+    };
+    "invalid-range": {
+        readonly default: import("./types.js").CallableMessage<["start", "end"]>;
+    };
+    "add-response": {
+        readonly default: "Cannot add a response to anything except an operation statement.";
+    };
+    "add-parameter": {
+        readonly default: "Cannot add a parameter to anything except an operation statement.";
+    };
+    "add-model-property": {
+        readonly default: "Cannot add a model property to anything except a model statement.";
+    };
+    "add-model-property-fail": {
+        readonly default: import("./types.js").CallableMessage<["propertyName", "propertyTypeName"]>;
+    };
+    "add-response-type": {
+        readonly default: import("./types.js").CallableMessage<["responseTypeName", "operationName"]>;
+    };
+    "circular-base-type": {
+        readonly default: import("./types.js").CallableMessage<["typeName"]>;
+    };
+    "circular-constraint": {
+        readonly default: import("./types.js").CallableMessage<["typeName"]>;
+    };
+    "circular-op-signature": {
+        readonly default: import("./types.js").CallableMessage<["typeName"]>;
+    };
+    "circular-alias-type": {
+        readonly default: import("./types.js").CallableMessage<["typeName"]>;
+    };
+    "circular-const": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "circular-prop": {
+        readonly default: import("./types.js").CallableMessage<["propName"]>;
+    };
+    "conflict-marker": {
+        readonly default: "Conflict marker encountered.";
+    };
+    "visibility-sealed": {
+        readonly default: import("./types.js").CallableMessage<["propName"]>;
+    };
+    "default-visibility-not-member": {
+        readonly default: "The default visibility modifiers of a class must be members of the class enum.";
+    };
+    "operation-visibility-constraint-empty": {
+        readonly default: "Operation visibility constraints with no arguments are not allowed.";
+        readonly returnType: "Return type visibility constraints with no arguments are not allowed.";
+        readonly parameter: "Parameter visibility constraints with no arguments are not allowed. To disable effective PATCH optionality, use @patch(#{ implicitOptionality: false }) instead.";
+    };
+    "no-compatible-vs-installed": {
+        readonly default: "No compatible version of Visual Studio found.";
+    };
+    "vs-extension-windows-only": {
+        readonly default: "Visual Studio extension is not supported on non-Windows.";
+    };
+    "vsix-download-failed": {
+        readonly default: import("./types.js").CallableMessage<["id", "message"]>;
+    };
+    "vscode-in-path": {
+        readonly default: "Couldn't find VS Code 'code' command in PATH. Make sure you have the VS Code executable added to the system PATH.";
+        readonly osx: "Couldn't find VS Code 'code' command in PATH. Make sure you have the VS Code executable added to the system PATH.\nSee instruction for Mac OS here https://code.visualstudio.com/docs/setup/mac";
+    };
+    "invalid-option-flag": {
+        readonly default: import("./types.js").CallableMessage<["value"]>;
+    };
+    "cli-command-deprecated": {
+        readonly default: import("./types.js").CallableMessage<["command", "docsUrl"]>;
+    };
+}[C] = "default">(diag: import("./types.js").DiagnosticReport<{
+    "digit-expected": {
+        readonly default: "Digit expected.";
+    };
+    "hex-digit-expected": {
+        readonly default: "Hexadecimal digit expected.";
+    };
+    "binary-digit-expected": {
+        readonly default: "Binary digit expected.";
+    };
+    unterminated: {
+        readonly default: import("./types.js").CallableMessage<["token"]>;
+    };
+    "creating-file": {
+        readonly default: import("./types.js").CallableMessage<["filename", "error"]>;
+    };
+    "invalid-escape-sequence": {
+        readonly default: "Invalid escape sequence.";
+    };
+    "no-new-line-start-triple-quote": {
+        readonly default: "String content in triple quotes must begin on a new line.";
+    };
+    "no-new-line-end-triple-quote": {
+        readonly default: "Closing triple quotes must begin on a new line.";
+    };
+    "triple-quote-indent": {
+        readonly default: "All lines in triple-quoted string lines must have the same indentation as closing triple quotes.";
+    };
+    "invalid-character": {
+        readonly default: "Invalid character.";
+    };
+    "file-not-found": {
+        readonly default: import("./types.js").CallableMessage<["path"]>;
+    };
+    "file-load": {
+        readonly default: import("./types.js").CallableMessage<["message"]>;
+    };
+    "init-template-invalid-json": {
+        readonly default: import("./types.js").CallableMessage<["url", "message"]>;
+    };
+    "init-template-download-failed": {
+        readonly default: import("./types.js").CallableMessage<["url", "message"]>;
+    };
+    "multiple-blockless-namespace": {
+        readonly default: "Cannot use multiple blockless namespaces.";
+    };
+    "blockless-namespace-first": {
+        readonly default: "Blockless namespaces can't follow other declarations.";
+        readonly topLevel: "Blockless namespace can only be top-level.";
+    };
+    "import-first": {
+        readonly default: "Imports must come prior to namespaces or other declarations.";
+        readonly topLevel: "Imports must be top-level and come prior to namespaces or other declarations.";
+    };
+    "duplicate-import": {
+        readonly default: import("./types.js").CallableMessage<["importPath"]>;
+    };
+    "self-import": {
+        readonly default: "A file cannot import itself.";
+    };
+    "token-expected": {
+        readonly default: import("./types.js").CallableMessage<["token"]>;
+        readonly unexpected: import("./types.js").CallableMessage<["token"]>;
+        readonly numericOrStringLiteral: "Expected numeric or string literal.";
+        readonly identifier: "Identifier expected.";
+        readonly expression: "Expression expected.";
+        readonly statement: "Statement expected.";
+        readonly property: "Property expected.";
+        readonly enumMember: "Enum member expected.";
+        readonly typeofTarget: "Typeof expects a value literal or value reference.";
+    };
+    "unknown-directive": {
+        readonly default: import("./types.js").CallableMessage<["id"]>;
+    };
+    "augment-decorator-target": {
+        readonly default: "Augment decorator first argument must be a type reference.";
+        readonly noInstance: "Cannot reference template instances.";
+        readonly noModelExpression: "Cannot augment model expressions.";
+        readonly noUnionExpression: "Cannot augment union expressions.";
+    };
+    "duplicate-decorator": {
+        readonly default: import("./types.js").CallableMessage<["decoratorName"]>;
+    };
+    "decorator-conflict": {
+        readonly default: import("./types.js").CallableMessage<["decoratorName", "otherDecoratorName"]>;
+    };
+    "reserved-identifier": {
+        readonly default: "Keyword cannot be used as identifier.";
+        readonly future: import("./types.js").CallableMessage<["name"]>;
+    };
+    "invalid-directive-location": {
+        readonly default: import("./types.js").CallableMessage<["nodeName"]>;
+    };
+    "invalid-decorator-location": {
+        readonly default: import("./types.js").CallableMessage<["nodeName"]>;
+    };
+    "default-required": {
+        readonly default: "Required template parameters must not follow optional template parameters";
+    };
+    "invalid-template-argument-name": {
+        readonly default: "Template parameter argument names must be valid, bare identifiers.";
+    };
+    "invalid-template-default": {
+        readonly default: "Template parameter defaults can only reference previously declared type parameters.";
+    };
+    "required-parameter-first": {
+        readonly default: "A required parameter cannot follow an optional parameter.";
+    };
+    "rest-parameter-last": {
+        readonly default: "A rest parameter must be last in a parameter list.";
+    };
+    "rest-parameter-required": {
+        readonly default: "A rest parameter cannot be optional.";
+    };
+    "doc-invalid-identifier": {
+        readonly default: "Invalid identifier.";
+        readonly tag: "Invalid tag name. Use backticks around code if this was not meant to be a tag.";
+        readonly param: "Invalid parameter name.";
+        readonly prop: "Invalid property name.";
+        readonly templateParam: "Invalid template parameter name.";
+    };
+    "experimental-feature": {
+        readonly default: import("./types.js").CallableMessage<["feature"]>;
+        readonly functionDeclarations: "Function declarations are an experimental feature that may change in the future. Use with caution and consider providing feedback to the TypeSpec team.";
+    };
+    "union-extends-disabled": {
+        readonly default: "Union `extends` clauses require the 'union-extends' feature to be enabled. Add 'union-extends' to the 'features' list in your tspconfig.yaml.";
+    };
+    "auto-decorator-disabled": {
+        readonly default: "Auto decorator declarations require the 'auto-decorators' feature to be enabled. Add 'auto-decorators' to the 'features' list in your tspconfig.yaml.";
+    };
+    "using-invalid-ref": {
+        readonly default: "Using must refer to a namespace";
+    };
+    "invalid-type-ref": {
+        readonly default: "Invalid type reference";
+        readonly decorator: "Can't put a decorator in a type";
+        readonly function: "Can't use a function as a type";
+    };
+    "invalid-template-args": {
+        readonly default: "Invalid template arguments.";
+        readonly notTemplate: "Can't pass template arguments to non-templated type";
+        readonly tooMany: "Too many template arguments provided.";
+        readonly unknownName: import("./types.js").CallableMessage<["name"]>;
+        readonly positionalAfterNamed: "Positional template arguments cannot follow named arguments in the same argument list.";
+        readonly missing: import("./types.js").CallableMessage<["name"]>;
+        readonly specifiedAgain: import("./types.js").CallableMessage<["name"]>;
+    };
+    "intersect-non-model": {
+        readonly default: "Cannot intersect non-model types (including union types).";
+    };
+    "intersect-invalid-index": {
+        readonly default: "Cannot intersect incompatible models.";
+        readonly never: "Cannot intersect a model that cannot hold properties.";
+        readonly array: "Cannot intersect an array model.";
+    };
+    "incompatible-indexer": {
+        readonly default: import("./types.js").CallableMessage<["message"]>;
+    };
+    "no-array-properties": {
+        readonly default: "Array models cannot have any properties.";
+    };
+    "intersect-duplicate-property": {
+        readonly default: import("./types.js").CallableMessage<["propName"]>;
+    };
+    "invalid-decorator": {
+        readonly default: import("./types.js").CallableMessage<["id"]>;
+    };
+    "invalid-ref": {
+        readonly default: import("./types.js").CallableMessage<["id"]>;
+        readonly identifier: import("./types.js").CallableMessage<["id"]>;
+        readonly decorator: import("./types.js").CallableMessage<["id"]>;
+        readonly inDecorator: import("./types.js").CallableMessage<["id"]>;
+        readonly underNamespace: import("./types.js").CallableMessage<["namespace", "id"]>;
+        readonly member: import("./types.js").CallableMessage<["kind", "id"]>;
+        readonly metaProperty: import("./types.js").CallableMessage<["kind", "id"]>;
+        readonly node: import("./types.js").CallableMessage<["id", "nodeName"]>;
+        readonly internal: import("./types.js").CallableMessage<["id"]>;
+    };
+    "duplicate-property": {
+        readonly default: import("./types.js").CallableMessage<["propName"]>;
+        readonly withModel: import("./types.js").CallableMessage<["modelName", "propName"]>;
+    };
+    "override-property-mismatch": {
+        readonly default: import("./types.js").CallableMessage<["propName", "propType", "parentType"]>;
+        readonly disallowedOptionalOverride: import("./types.js").CallableMessage<["propName"]>;
+    };
+    "extend-scalar": {
+        readonly default: "Scalar must extend other scalars.";
+    };
+    "extend-model": {
+        readonly default: "Models must extend other models.";
+        readonly modelExpression: "Models cannot extend model expressions.";
+    };
+    "extend-union": {
+        readonly default: "Union `extends` must specify a model, scalar, enum, or union.";
+        readonly modelExpression: "Unions cannot extend model expressions.";
+    };
+    "is-model": {
+        readonly default: "Model `is` must specify another model.";
+        readonly modelExpression: "Model `is` cannot specify a model expression.";
+    };
+    "is-operation": {
+        readonly default: "Operation can only reuse the signature of another operation.";
+    };
+    "spread-model": {
+        readonly default: "Cannot spread properties of non-model type.";
+        readonly neverIndex: "Cannot spread type because it cannot hold properties.";
+        readonly selfSpread: "Cannot spread type within its own declaration.";
+    };
+    "unsupported-default": {
+        readonly default: import("./types.js").CallableMessage<["type"]>;
+    };
+    "spread-object": {
+        readonly default: "Cannot spread properties of non-object type.";
+    };
+    "expect-value": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+        readonly model: import("./types.js").CallableMessage<["name"]>;
+        readonly modelExpression: "Is a model expression type, but is being used as a value here. Use #{} to create an object value.";
+        readonly tuple: "Is a tuple type, but is being used as a value here. Use #[] to create an array value.";
+        readonly templateConstraint: import("./types.js").CallableMessage<["name"]>;
+        readonly functionReturn: import("./types.js").CallableMessage<[]>;
+    };
+    "non-callable": {
+        readonly default: import("./types.js").CallableMessage<["type"]>;
+        readonly templateParameter: import("./types.js").CallableMessage<["name", "constraint"]>;
+    };
+    "named-init-required": {
+        readonly default: import("./types.js").CallableMessage<[]>;
+    };
+    "invalid-primitive-init": {
+        readonly default: "Instantiating scalar deriving from 'string', 'numeric' or 'boolean' can only take a single argument.";
+        readonly invalidArg: import("./types.js").CallableMessage<["expected", "actual"]>;
+    };
+    "ambiguous-scalar-type": {
+        readonly default: import("./types.js").CallableMessage<["value", "types", "example", "value"]>;
+    };
+    unassignable: {
+        readonly default: import("./types.js").CallableMessage<["sourceType", "targetType"]>;
+    };
+    "property-unassignable": {
+        readonly default: import("./types.js").CallableMessage<["propName"]>;
+    };
+    "property-required": {
+        readonly default: import("./types.js").CallableMessage<["propName", "targetType"]>;
+    };
+    "parameter-required": {
+        readonly default: import("./types.js").CallableMessage<["paramName"]>;
+        readonly missing: import("./types.js").CallableMessage<["paramName"]>;
+        readonly "rest-to-required": import("./types.js").CallableMessage<["paramName"]>;
+    };
+    "value-in-type": {
+        readonly default: "A value cannot be used as a type.";
+        readonly referenceTemplate: "Template parameter can be passed values but is used as a type.";
+        readonly noTemplateConstraint: "Template parameter has no constraint but a value is passed. Add `extends valueof unknown` to accept any value.";
+    };
+    "no-prop": {
+        readonly default: import("./types.js").CallableMessage<["propName"]>;
+    };
+    "missing-index": {
+        readonly default: import("./types.js").CallableMessage<["indexType", "sourceType"]>;
+    };
+    "missing-property": {
+        readonly default: import("./types.js").CallableMessage<["propertyName", "sourceType", "targetType"]>;
+    };
+    "unexpected-property": {
+        readonly default: import("./types.js").CallableMessage<["propertyName", "type"]>;
+    };
+    "extends-interface": {
+        readonly default: "Interfaces can only extend other interfaces";
+    };
+    "extends-interface-duplicate": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "interface-duplicate": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "union-duplicate": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "enum-member-duplicate": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "constructor-duplicate": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "spread-enum": {
+        readonly default: "Cannot spread members of non-enum type.";
+    };
+    "decorator-fail": {
+        readonly default: import("./types.js").CallableMessage<["decoratorName", "error"]>;
+    };
+    "rest-parameter-array": {
+        readonly default: "A rest parameter must be of an array type.";
+    };
+    "invalid-modifier": {
+        readonly default: import("./types.js").CallableMessage<["modifier"]>;
+        readonly "missing-required": import("./types.js").CallableMessage<["nodeKind", "modifier"]>;
+        readonly "missing-required-one-of": import("./types.js").CallableMessage<["nodeKind", "modifiers"]>;
+        readonly "mutually-exclusive": import("./types.js").CallableMessage<["modifierA", "modifierB"]>;
+        readonly "not-allowed": import("./types.js").CallableMessage<["modifier", "nodeKind"]>;
+    };
+    "function-return": {
+        readonly default: "Function implementation returned an invalid result.";
+        readonly "invalid-value": import("./types.js").CallableMessage<["value"]>;
+        readonly unassignable: import("./types.js").CallableMessage<["name", "entityKind", "return", "type"]>;
+    };
+    "fn-in-union-expression": {
+        readonly default: "Function types in anonymous union expressions must be parenthesized.";
+    };
+    "missing-implementation": {
+        readonly default: "Extern declaration must have an implementation in JS file.";
+    };
+    "missing-extern-declaration": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "overload-same-parent": {
+        readonly default: "Overload must be in the same interface or namespace.";
+    };
+    shadow: {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "invalid-deprecation-argument": {
+        readonly default: import("./types.js").CallableMessage<["kind"]>;
+        readonly missing: "#deprecation directive is expecting a message argument but none was provided.";
+    };
+    "duplicate-deprecation": {
+        readonly default: "The #deprecated directive cannot be used more than once on the same declaration.";
+    };
+    "config-invalid-argument": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "config-circular-variable": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "config-path-absolute": {
+        readonly default: import("./types.js").CallableMessage<["path"]>;
+    };
+    "config-invalid-name": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "path-unix-style": {
+        readonly default: import("./types.js").CallableMessage<[]>;
+    };
+    "config-path-not-found": {
+        readonly default: import("./types.js").CallableMessage<["path"]>;
+    };
+    "config-project-kind-filename": {
+        readonly default: import("./types.js").CallableMessage<["filename"]>;
+    };
+    "config-project-only-option": {
+        readonly default: import("./types.js").CallableMessage<["option"]>;
+    };
+    "config-unknown-feature": {
+        readonly default: import("./types.js").CallableMessage<["feature"]>;
+    };
+    "config-project-not-as-cli-config": {
+        readonly default: "`--config` cannot point to a project config (with `kind: project`). Use a non-project build config that `extends` the project config instead.";
+    };
+    "dynamic-import": {
+        readonly default: "Dynamically generated TypeSpec cannot have imports";
+    };
+    "invalid-import": {
+        readonly default: "Import paths must reference either a directory, a .tsp file, or .js file";
+    };
+    "invalid-main": {
+        readonly default: "Main file must either be a .tsp file or a .js file.";
+    };
+    "import-not-found": {
+        readonly default: import("./types.js").CallableMessage<["path"]>;
+    };
+    "library-invalid": {
+        readonly default: import("./types.js").CallableMessage<["path", "message"]>;
+    };
+    "incompatible-library": {
+        readonly default: import("./types.js").CallableMessage<["name", "versionMap"]>;
+    };
+    "compiler-version-mismatch": {
+        readonly default: import("./types.js").CallableMessage<["basedir", "basedir", "betterTypeSpecServerPath", "expected", "actual"]>;
+    };
+    "duplicate-symbol": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "duplicate-suppression": {
+        readonly default: import("./types.js").CallableMessage<["code"]>;
+    };
+    "ambiguous-short-name": {
+        readonly default: import("./types.js").CallableMessage<["shortName", "candidates"]>;
+    };
+    "decorator-decl-target": {
+        readonly default: "dec must have at least one parameter.";
+        readonly required: "dec first parameter must be required.";
+    };
+    "mixed-string-template": {
+        readonly default: "String template is interpolating values and types. It must be either all values to produce a string value or or all types for string template type.";
+    };
+    "non-literal-string-template": {
+        readonly default: "Value interpolated in this string template cannot be converted to a string. Only literal types can be automatically interpolated.";
+    };
+    "ambiguous-symbol": {
+        readonly default: import("./types.js").CallableMessage<["name", "duplicateNames", "duplicateNames"]>;
+    };
+    "duplicate-using": {
+        readonly default: import("./types.js").CallableMessage<["usingName"]>;
+    };
+    "on-validate-fail": {
+        readonly default: import("./types.js").CallableMessage<["error"]>;
+    };
+    "emitter-not-found": {
+        readonly default: import("./types.js").CallableMessage<["emitterPackage", "emitterPackage"]>;
+    };
+    "invalid-emitter": {
+        readonly default: import("./types.js").CallableMessage<["emitterPackage"]>;
+    };
+    "js-error": {
+        readonly default: import("./types.js").CallableMessage<["specifier", "error"]>;
+    };
+    "missing-import": {
+        readonly default: import("./types.js").CallableMessage<["emitterName", "requiredImport", "requiredImport"]>;
+    };
+    "invalid-rule-ref": {
+        readonly default: import("./types.js").CallableMessage<["ref"]>;
+    };
+    "unknown-rule": {
+        readonly default: import("./types.js").CallableMessage<["ruleName", "libraryName"]>;
+    };
+    "unknown-rule-set": {
+        readonly default: import("./types.js").CallableMessage<["ruleSetName", "libraryName"]>;
+    };
+    "rule-enabled-disabled": {
+        readonly default: import("./types.js").CallableMessage<["ruleName"]>;
+    };
+    "invalid-rule-options": {
+        readonly default: import("./types.js").CallableMessage<["ruleName", "details"]>;
+    };
+    "circular-ruleset-file": {
+        readonly default: import("./types.js").CallableMessage<["path"]>;
+    };
+    "ruleset-file-in-library": {
+        readonly default: import("./types.js").CallableMessage<["ruleSetName", "ref"]>;
+    };
+    "format-failed": {
+        readonly default: import("./types.js").CallableMessage<["file", "details"]>;
+    };
+    "invalid-pattern-regex": {
+        readonly default: "@pattern decorator expects a valid regular expression pattern.";
+    };
+    "decorator-wrong-target": {
+        readonly default: import("./types.js").CallableMessage<["decorator", "to"]>;
+        readonly withExpected: import("./types.js").CallableMessage<["decorator", "to", "expected"]>;
+    };
+    "invalid-argument": {
+        readonly default: import("./types.js").CallableMessage<["value", "expected"]>;
+    };
+    "invalid-argument-count": {
+        readonly default: import("./types.js").CallableMessage<["expected", "actual"]>;
+        readonly atLeast: import("./types.js").CallableMessage<["expected", "actual"]>;
+    };
+    "known-values-invalid-enum": {
+        readonly default: import("./types.js").CallableMessage<["member", "type"]>;
+    };
+    "invalid-value": {
+        readonly default: import("./types.js").CallableMessage<["kind"]>;
+        readonly atPath: import("./types.js").CallableMessage<["kind", "path"]>;
+    };
+    deprecated: {
+        readonly default: import("./types.js").CallableMessage<["message"]>;
+    };
+    "no-optional-key": {
+        readonly default: import("./types.js").CallableMessage<["propertyName"]>;
+    };
+    "invalid-discriminated-union": {
+        readonly default: "";
+        readonly noAnonVariants: "Unions with anonymous variants cannot be discriminated";
+    };
+    "invalid-discriminated-union-variant": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+        readonly noEnvelopeModel: import("./types.js").CallableMessage<["name"]>;
+        readonly discriminantMismatch: import("./types.js").CallableMessage<["name", "discriminant", "propertyValue", "variantName"]>;
+        readonly duplicateDefaultVariant: import("./types.js").CallableMessage<["unionName"]>;
+        readonly noDiscriminant: import("./types.js").CallableMessage<["name", "discriminant"]>;
+        readonly wrongDiscriminantType: import("./types.js").CallableMessage<["name", "discriminant"]>;
+    };
+    "missing-discriminator-property": {
+        readonly default: import("./types.js").CallableMessage<["discriminator", "discriminator"]>;
+    };
+    "invalid-discriminator-value": {
+        readonly default: import("./types.js").CallableMessage<["kind"]>;
+        readonly required: "The discriminator property must be a required property.";
+        readonly duplicate: import("./types.js").CallableMessage<["discriminator"]>;
+    };
+    "invalid-encode": {
+        readonly default: "Invalid encoding";
+        readonly wrongType: import("./types.js").CallableMessage<["encoding", "type", "expected"]>;
+        readonly wrongEncodingType: import("./types.js").CallableMessage<["encoding", "type", "expected", "actual"]>;
+        readonly wrongNumericEncodingType: import("./types.js").CallableMessage<["encoding", "type", "expected", "actual", "expected", "encoding"]>;
+        readonly firstArg: "First argument of \"@encode\" must be the encoding name or the string type when encoding numeric or boolean types.";
+    };
+    "invalid-mime-type": {
+        readonly default: import("./types.js").CallableMessage<["mimeType"]>;
+    };
+    "no-mime-type-suffix": {
+        readonly default: import("./types.js").CallableMessage<["mimeType", "suffix"]>;
+    };
+    "encoded-name-conflict": {
+        readonly default: import("./types.js").CallableMessage<["name", "mimeType"]>;
+        readonly duplicate: import("./types.js").CallableMessage<["name", "mimeType"]>;
+    };
+    "incompatible-paging-props": {
+        readonly default: import("./types.js").CallableMessage<["kinds"]>;
+    };
+    "invalid-paging-prop": {
+        readonly default: import("./types.js").CallableMessage<["kind"]>;
+        readonly input: import("./types.js").CallableMessage<["kind"]>;
+        readonly output: import("./types.js").CallableMessage<["kind"]>;
+    };
+    "duplicate-paging-prop": {
+        readonly default: import("./types.js").CallableMessage<["kind", "operationName"]>;
+    };
+    "missing-paging-items": {
+        readonly default: import("./types.js").CallableMessage<["operationName"]>;
+    };
+    "service-decorator-duplicate": {
+        readonly default: "@service can only be set once per TypeSpec document.";
+    };
+    "list-type-not-model": {
+        readonly default: "@list decorator's parameter must be a model type.";
+    };
+    "invalid-range": {
+        readonly default: import("./types.js").CallableMessage<["start", "end"]>;
+    };
+    "add-response": {
+        readonly default: "Cannot add a response to anything except an operation statement.";
+    };
+    "add-parameter": {
+        readonly default: "Cannot add a parameter to anything except an operation statement.";
+    };
+    "add-model-property": {
+        readonly default: "Cannot add a model property to anything except a model statement.";
+    };
+    "add-model-property-fail": {
+        readonly default: import("./types.js").CallableMessage<["propertyName", "propertyTypeName"]>;
+    };
+    "add-response-type": {
+        readonly default: import("./types.js").CallableMessage<["responseTypeName", "operationName"]>;
+    };
+    "circular-base-type": {
+        readonly default: import("./types.js").CallableMessage<["typeName"]>;
+    };
+    "circular-constraint": {
+        readonly default: import("./types.js").CallableMessage<["typeName"]>;
+    };
+    "circular-op-signature": {
+        readonly default: import("./types.js").CallableMessage<["typeName"]>;
+    };
+    "circular-alias-type": {
+        readonly default: import("./types.js").CallableMessage<["typeName"]>;
+    };
+    "circular-const": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "circular-prop": {
+        readonly default: import("./types.js").CallableMessage<["propName"]>;
+    };
+    "conflict-marker": {
+        readonly default: "Conflict marker encountered.";
+    };
+    "visibility-sealed": {
+        readonly default: import("./types.js").CallableMessage<["propName"]>;
+    };
+    "default-visibility-not-member": {
+        readonly default: "The default visibility modifiers of a class must be members of the class enum.";
+    };
+    "operation-visibility-constraint-empty": {
+        readonly default: "Operation visibility constraints with no arguments are not allowed.";
+        readonly returnType: "Return type visibility constraints with no arguments are not allowed.";
+        readonly parameter: "Parameter visibility constraints with no arguments are not allowed. To disable effective PATCH optionality, use @patch(#{ implicitOptionality: false }) instead.";
+    };
+    "no-compatible-vs-installed": {
+        readonly default: "No compatible version of Visual Studio found.";
+    };
+    "vs-extension-windows-only": {
+        readonly default: "Visual Studio extension is not supported on non-Windows.";
+    };
+    "vsix-download-failed": {
+        readonly default: import("./types.js").CallableMessage<["id", "message"]>;
+    };
+    "vscode-in-path": {
+        readonly default: "Couldn't find VS Code 'code' command in PATH. Make sure you have the VS Code executable added to the system PATH.";
+        readonly osx: "Couldn't find VS Code 'code' command in PATH. Make sure you have the VS Code executable added to the system PATH.\nSee instruction for Mac OS here https://code.visualstudio.com/docs/setup/mac";
+    };
+    "invalid-option-flag": {
+        readonly default: import("./types.js").CallableMessage<["value"]>;
+    };
+    "cli-command-deprecated": {
+        readonly default: import("./types.js").CallableMessage<["command", "docsUrl"]>;
+    };
+}, C, M>) => import("./types.js").Diagnostic, reportDiagnostic: <C extends "digit-expected" | "hex-digit-expected" | "binary-digit-expected" | "unterminated" | "creating-file" | "invalid-escape-sequence" | "no-new-line-start-triple-quote" | "no-new-line-end-triple-quote" | "triple-quote-indent" | "invalid-character" | "file-not-found" | "file-load" | "init-template-invalid-json" | "init-template-download-failed" | "multiple-blockless-namespace" | "blockless-namespace-first" | "import-first" | "duplicate-import" | "self-import" | "token-expected" | "unknown-directive" | "augment-decorator-target" | "duplicate-decorator" | "decorator-conflict" | "reserved-identifier" | "invalid-directive-location" | "invalid-decorator-location" | "default-required" | "invalid-template-argument-name" | "invalid-template-default" | "required-parameter-first" | "rest-parameter-last" | "rest-parameter-required" | "doc-invalid-identifier" | "experimental-feature" | "union-extends-disabled" | "auto-decorator-disabled" | "using-invalid-ref" | "invalid-type-ref" | "invalid-template-args" | "intersect-non-model" | "intersect-invalid-index" | "incompatible-indexer" | "no-array-properties" | "intersect-duplicate-property" | "invalid-decorator" | "invalid-ref" | "duplicate-property" | "override-property-mismatch" | "extend-scalar" | "extend-model" | "extend-union" | "is-model" | "is-operation" | "spread-model" | "unsupported-default" | "spread-object" | "expect-value" | "non-callable" | "named-init-required" | "invalid-primitive-init" | "ambiguous-scalar-type" | "unassignable" | "property-unassignable" | "property-required" | "parameter-required" | "value-in-type" | "no-prop" | "missing-index" | "missing-property" | "unexpected-property" | "extends-interface" | "extends-interface-duplicate" | "interface-duplicate" | "union-duplicate" | "enum-member-duplicate" | "constructor-duplicate" | "spread-enum" | "decorator-fail" | "rest-parameter-array" | "invalid-modifier" | "function-return" | "invalid-value" | "fn-in-union-expression" | "missing-implementation" | "missing-extern-declaration" | "overload-same-parent" | "shadow" | "invalid-deprecation-argument" | "duplicate-deprecation" | "config-invalid-argument" | "config-circular-variable" | "config-path-absolute" | "config-invalid-name" | "path-unix-style" | "config-path-not-found" | "config-project-kind-filename" | "config-project-only-option" | "config-unknown-feature" | "config-project-not-as-cli-config" | "dynamic-import" | "invalid-import" | "invalid-main" | "import-not-found" | "library-invalid" | "incompatible-library" | "compiler-version-mismatch" | "duplicate-symbol" | "duplicate-suppression" | "ambiguous-short-name" | "decorator-decl-target" | "mixed-string-template" | "non-literal-string-template" | "ambiguous-symbol" | "duplicate-using" | "on-validate-fail" | "emitter-not-found" | "invalid-emitter" | "js-error" | "missing-import" | "invalid-rule-ref" | "unknown-rule" | "unknown-rule-set" | "rule-enabled-disabled" | "invalid-rule-options" | "circular-ruleset-file" | "ruleset-file-in-library" | "format-failed" | "invalid-pattern-regex" | "decorator-wrong-target" | "invalid-argument" | "invalid-argument-count" | "known-values-invalid-enum" | "deprecated" | "no-optional-key" | "invalid-discriminated-union" | "invalid-discriminated-union-variant" | "missing-discriminator-property" | "invalid-discriminator-value" | "invalid-encode" | "invalid-mime-type" | "no-mime-type-suffix" | "encoded-name-conflict" | "incompatible-paging-props" | "invalid-paging-prop" | "duplicate-paging-prop" | "missing-paging-items" | "service-decorator-duplicate" | "list-type-not-model" | "invalid-range" | "add-response" | "add-parameter" | "add-model-property" | "add-model-property-fail" | "add-response-type" | "circular-base-type" | "circular-constraint" | "circular-op-signature" | "circular-alias-type" | "circular-const" | "circular-prop" | "conflict-marker" | "visibility-sealed" | "default-visibility-not-member" | "operation-visibility-constraint-empty" | "no-compatible-vs-installed" | "vs-extension-windows-only" | "vsix-download-failed" | "vscode-in-path" | "invalid-option-flag" | "cli-command-deprecated", M extends keyof {
+    "digit-expected": {
+        readonly default: "Digit expected.";
+    };
+    "hex-digit-expected": {
+        readonly default: "Hexadecimal digit expected.";
+    };
+    "binary-digit-expected": {
+        readonly default: "Binary digit expected.";
+    };
+    unterminated: {
+        readonly default: import("./types.js").CallableMessage<["token"]>;
+    };
+    "creating-file": {
+        readonly default: import("./types.js").CallableMessage<["filename", "error"]>;
+    };
+    "invalid-escape-sequence": {
+        readonly default: "Invalid escape sequence.";
+    };
+    "no-new-line-start-triple-quote": {
+        readonly default: "String content in triple quotes must begin on a new line.";
+    };
+    "no-new-line-end-triple-quote": {
+        readonly default: "Closing triple quotes must begin on a new line.";
+    };
+    "triple-quote-indent": {
+        readonly default: "All lines in triple-quoted string lines must have the same indentation as closing triple quotes.";
+    };
+    "invalid-character": {
+        readonly default: "Invalid character.";
+    };
+    "file-not-found": {
+        readonly default: import("./types.js").CallableMessage<["path"]>;
+    };
+    "file-load": {
+        readonly default: import("./types.js").CallableMessage<["message"]>;
+    };
+    "init-template-invalid-json": {
+        readonly default: import("./types.js").CallableMessage<["url", "message"]>;
+    };
+    "init-template-download-failed": {
+        readonly default: import("./types.js").CallableMessage<["url", "message"]>;
+    };
+    "multiple-blockless-namespace": {
+        readonly default: "Cannot use multiple blockless namespaces.";
+    };
+    "blockless-namespace-first": {
+        readonly default: "Blockless namespaces can't follow other declarations.";
+        readonly topLevel: "Blockless namespace can only be top-level.";
+    };
+    "import-first": {
+        readonly default: "Imports must come prior to namespaces or other declarations.";
+        readonly topLevel: "Imports must be top-level and come prior to namespaces or other declarations.";
+    };
+    "duplicate-import": {
+        readonly default: import("./types.js").CallableMessage<["importPath"]>;
+    };
+    "self-import": {
+        readonly default: "A file cannot import itself.";
+    };
+    "token-expected": {
+        readonly default: import("./types.js").CallableMessage<["token"]>;
+        readonly unexpected: import("./types.js").CallableMessage<["token"]>;
+        readonly numericOrStringLiteral: "Expected numeric or string literal.";
+        readonly identifier: "Identifier expected.";
+        readonly expression: "Expression expected.";
+        readonly statement: "Statement expected.";
+        readonly property: "Property expected.";
+        readonly enumMember: "Enum member expected.";
+        readonly typeofTarget: "Typeof expects a value literal or value reference.";
+    };
+    "unknown-directive": {
+        readonly default: import("./types.js").CallableMessage<["id"]>;
+    };
+    "augment-decorator-target": {
+        readonly default: "Augment decorator first argument must be a type reference.";
+        readonly noInstance: "Cannot reference template instances.";
+        readonly noModelExpression: "Cannot augment model expressions.";
+        readonly noUnionExpression: "Cannot augment union expressions.";
+    };
+    "duplicate-decorator": {
+        readonly default: import("./types.js").CallableMessage<["decoratorName"]>;
+    };
+    "decorator-conflict": {
+        readonly default: import("./types.js").CallableMessage<["decoratorName", "otherDecoratorName"]>;
+    };
+    "reserved-identifier": {
+        readonly default: "Keyword cannot be used as identifier.";
+        readonly future: import("./types.js").CallableMessage<["name"]>;
+    };
+    "invalid-directive-location": {
+        readonly default: import("./types.js").CallableMessage<["nodeName"]>;
+    };
+    "invalid-decorator-location": {
+        readonly default: import("./types.js").CallableMessage<["nodeName"]>;
+    };
+    "default-required": {
+        readonly default: "Required template parameters must not follow optional template parameters";
+    };
+    "invalid-template-argument-name": {
+        readonly default: "Template parameter argument names must be valid, bare identifiers.";
+    };
+    "invalid-template-default": {
+        readonly default: "Template parameter defaults can only reference previously declared type parameters.";
+    };
+    "required-parameter-first": {
+        readonly default: "A required parameter cannot follow an optional parameter.";
+    };
+    "rest-parameter-last": {
+        readonly default: "A rest parameter must be last in a parameter list.";
+    };
+    "rest-parameter-required": {
+        readonly default: "A rest parameter cannot be optional.";
+    };
+    "doc-invalid-identifier": {
+        readonly default: "Invalid identifier.";
+        readonly tag: "Invalid tag name. Use backticks around code if this was not meant to be a tag.";
+        readonly param: "Invalid parameter name.";
+        readonly prop: "Invalid property name.";
+        readonly templateParam: "Invalid template parameter name.";
+    };
+    "experimental-feature": {
+        readonly default: import("./types.js").CallableMessage<["feature"]>;
+        readonly functionDeclarations: "Function declarations are an experimental feature that may change in the future. Use with caution and consider providing feedback to the TypeSpec team.";
+    };
+    "union-extends-disabled": {
+        readonly default: "Union `extends` clauses require the 'union-extends' feature to be enabled. Add 'union-extends' to the 'features' list in your tspconfig.yaml.";
+    };
+    "auto-decorator-disabled": {
+        readonly default: "Auto decorator declarations require the 'auto-decorators' feature to be enabled. Add 'auto-decorators' to the 'features' list in your tspconfig.yaml.";
+    };
+    "using-invalid-ref": {
+        readonly default: "Using must refer to a namespace";
+    };
+    "invalid-type-ref": {
+        readonly default: "Invalid type reference";
+        readonly decorator: "Can't put a decorator in a type";
+        readonly function: "Can't use a function as a type";
+    };
+    "invalid-template-args": {
+        readonly default: "Invalid template arguments.";
+        readonly notTemplate: "Can't pass template arguments to non-templated type";
+        readonly tooMany: "Too many template arguments provided.";
+        readonly unknownName: import("./types.js").CallableMessage<["name"]>;
+        readonly positionalAfterNamed: "Positional template arguments cannot follow named arguments in the same argument list.";
+        readonly missing: import("./types.js").CallableMessage<["name"]>;
+        readonly specifiedAgain: import("./types.js").CallableMessage<["name"]>;
+    };
+    "intersect-non-model": {
+        readonly default: "Cannot intersect non-model types (including union types).";
+    };
+    "intersect-invalid-index": {
+        readonly default: "Cannot intersect incompatible models.";
+        readonly never: "Cannot intersect a model that cannot hold properties.";
+        readonly array: "Cannot intersect an array model.";
+    };
+    "incompatible-indexer": {
+        readonly default: import("./types.js").CallableMessage<["message"]>;
+    };
+    "no-array-properties": {
+        readonly default: "Array models cannot have any properties.";
+    };
+    "intersect-duplicate-property": {
+        readonly default: import("./types.js").CallableMessage<["propName"]>;
+    };
+    "invalid-decorator": {
+        readonly default: import("./types.js").CallableMessage<["id"]>;
+    };
+    "invalid-ref": {
+        readonly default: import("./types.js").CallableMessage<["id"]>;
+        readonly identifier: import("./types.js").CallableMessage<["id"]>;
+        readonly decorator: import("./types.js").CallableMessage<["id"]>;
+        readonly inDecorator: import("./types.js").CallableMessage<["id"]>;
+        readonly underNamespace: import("./types.js").CallableMessage<["namespace", "id"]>;
+        readonly member: import("./types.js").CallableMessage<["kind", "id"]>;
+        readonly metaProperty: import("./types.js").CallableMessage<["kind", "id"]>;
+        readonly node: import("./types.js").CallableMessage<["id", "nodeName"]>;
+        readonly internal: import("./types.js").CallableMessage<["id"]>;
+    };
+    "duplicate-property": {
+        readonly default: import("./types.js").CallableMessage<["propName"]>;
+        readonly withModel: import("./types.js").CallableMessage<["modelName", "propName"]>;
+    };
+    "override-property-mismatch": {
+        readonly default: import("./types.js").CallableMessage<["propName", "propType", "parentType"]>;
+        readonly disallowedOptionalOverride: import("./types.js").CallableMessage<["propName"]>;
+    };
+    "extend-scalar": {
+        readonly default: "Scalar must extend other scalars.";
+    };
+    "extend-model": {
+        readonly default: "Models must extend other models.";
+        readonly modelExpression: "Models cannot extend model expressions.";
+    };
+    "extend-union": {
+        readonly default: "Union `extends` must specify a model, scalar, enum, or union.";
+        readonly modelExpression: "Unions cannot extend model expressions.";
+    };
+    "is-model": {
+        readonly default: "Model `is` must specify another model.";
+        readonly modelExpression: "Model `is` cannot specify a model expression.";
+    };
+    "is-operation": {
+        readonly default: "Operation can only reuse the signature of another operation.";
+    };
+    "spread-model": {
+        readonly default: "Cannot spread properties of non-model type.";
+        readonly neverIndex: "Cannot spread type because it cannot hold properties.";
+        readonly selfSpread: "Cannot spread type within its own declaration.";
+    };
+    "unsupported-default": {
+        readonly default: import("./types.js").CallableMessage<["type"]>;
+    };
+    "spread-object": {
+        readonly default: "Cannot spread properties of non-object type.";
+    };
+    "expect-value": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+        readonly model: import("./types.js").CallableMessage<["name"]>;
+        readonly modelExpression: "Is a model expression type, but is being used as a value here. Use #{} to create an object value.";
+        readonly tuple: "Is a tuple type, but is being used as a value here. Use #[] to create an array value.";
+        readonly templateConstraint: import("./types.js").CallableMessage<["name"]>;
+        readonly functionReturn: import("./types.js").CallableMessage<[]>;
+    };
+    "non-callable": {
+        readonly default: import("./types.js").CallableMessage<["type"]>;
+        readonly templateParameter: import("./types.js").CallableMessage<["name", "constraint"]>;
+    };
+    "named-init-required": {
+        readonly default: import("./types.js").CallableMessage<[]>;
+    };
+    "invalid-primitive-init": {
+        readonly default: "Instantiating scalar deriving from 'string', 'numeric' or 'boolean' can only take a single argument.";
+        readonly invalidArg: import("./types.js").CallableMessage<["expected", "actual"]>;
+    };
+    "ambiguous-scalar-type": {
+        readonly default: import("./types.js").CallableMessage<["value", "types", "example", "value"]>;
+    };
+    unassignable: {
+        readonly default: import("./types.js").CallableMessage<["sourceType", "targetType"]>;
+    };
+    "property-unassignable": {
+        readonly default: import("./types.js").CallableMessage<["propName"]>;
+    };
+    "property-required": {
+        readonly default: import("./types.js").CallableMessage<["propName", "targetType"]>;
+    };
+    "parameter-required": {
+        readonly default: import("./types.js").CallableMessage<["paramName"]>;
+        readonly missing: import("./types.js").CallableMessage<["paramName"]>;
+        readonly "rest-to-required": import("./types.js").CallableMessage<["paramName"]>;
+    };
+    "value-in-type": {
+        readonly default: "A value cannot be used as a type.";
+        readonly referenceTemplate: "Template parameter can be passed values but is used as a type.";
+        readonly noTemplateConstraint: "Template parameter has no constraint but a value is passed. Add `extends valueof unknown` to accept any value.";
+    };
+    "no-prop": {
+        readonly default: import("./types.js").CallableMessage<["propName"]>;
+    };
+    "missing-index": {
+        readonly default: import("./types.js").CallableMessage<["indexType", "sourceType"]>;
+    };
+    "missing-property": {
+        readonly default: import("./types.js").CallableMessage<["propertyName", "sourceType", "targetType"]>;
+    };
+    "unexpected-property": {
+        readonly default: import("./types.js").CallableMessage<["propertyName", "type"]>;
+    };
+    "extends-interface": {
+        readonly default: "Interfaces can only extend other interfaces";
+    };
+    "extends-interface-duplicate": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "interface-duplicate": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "union-duplicate": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "enum-member-duplicate": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "constructor-duplicate": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "spread-enum": {
+        readonly default: "Cannot spread members of non-enum type.";
+    };
+    "decorator-fail": {
+        readonly default: import("./types.js").CallableMessage<["decoratorName", "error"]>;
+    };
+    "rest-parameter-array": {
+        readonly default: "A rest parameter must be of an array type.";
+    };
+    "invalid-modifier": {
+        readonly default: import("./types.js").CallableMessage<["modifier"]>;
+        readonly "missing-required": import("./types.js").CallableMessage<["nodeKind", "modifier"]>;
+        readonly "missing-required-one-of": import("./types.js").CallableMessage<["nodeKind", "modifiers"]>;
+        readonly "mutually-exclusive": import("./types.js").CallableMessage<["modifierA", "modifierB"]>;
+        readonly "not-allowed": import("./types.js").CallableMessage<["modifier", "nodeKind"]>;
+    };
+    "function-return": {
+        readonly default: "Function implementation returned an invalid result.";
+        readonly "invalid-value": import("./types.js").CallableMessage<["value"]>;
+        readonly unassignable: import("./types.js").CallableMessage<["name", "entityKind", "return", "type"]>;
+    };
+    "fn-in-union-expression": {
+        readonly default: "Function types in anonymous union expressions must be parenthesized.";
+    };
+    "missing-implementation": {
+        readonly default: "Extern declaration must have an implementation in JS file.";
+    };
+    "missing-extern-declaration": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "overload-same-parent": {
+        readonly default: "Overload must be in the same interface or namespace.";
+    };
+    shadow: {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "invalid-deprecation-argument": {
+        readonly default: import("./types.js").CallableMessage<["kind"]>;
+        readonly missing: "#deprecation directive is expecting a message argument but none was provided.";
+    };
+    "duplicate-deprecation": {
+        readonly default: "The #deprecated directive cannot be used more than once on the same declaration.";
+    };
+    "config-invalid-argument": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "config-circular-variable": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "config-path-absolute": {
+        readonly default: import("./types.js").CallableMessage<["path"]>;
+    };
+    "config-invalid-name": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "path-unix-style": {
+        readonly default: import("./types.js").CallableMessage<[]>;
+    };
+    "config-path-not-found": {
+        readonly default: import("./types.js").CallableMessage<["path"]>;
+    };
+    "config-project-kind-filename": {
+        readonly default: import("./types.js").CallableMessage<["filename"]>;
+    };
+    "config-project-only-option": {
+        readonly default: import("./types.js").CallableMessage<["option"]>;
+    };
+    "config-unknown-feature": {
+        readonly default: import("./types.js").CallableMessage<["feature"]>;
+    };
+    "config-project-not-as-cli-config": {
+        readonly default: "`--config` cannot point to a project config (with `kind: project`). Use a non-project build config that `extends` the project config instead.";
+    };
+    "dynamic-import": {
+        readonly default: "Dynamically generated TypeSpec cannot have imports";
+    };
+    "invalid-import": {
+        readonly default: "Import paths must reference either a directory, a .tsp file, or .js file";
+    };
+    "invalid-main": {
+        readonly default: "Main file must either be a .tsp file or a .js file.";
+    };
+    "import-not-found": {
+        readonly default: import("./types.js").CallableMessage<["path"]>;
+    };
+    "library-invalid": {
+        readonly default: import("./types.js").CallableMessage<["path", "message"]>;
+    };
+    "incompatible-library": {
+        readonly default: import("./types.js").CallableMessage<["name", "versionMap"]>;
+    };
+    "compiler-version-mismatch": {
+        readonly default: import("./types.js").CallableMessage<["basedir", "basedir", "betterTypeSpecServerPath", "expected", "actual"]>;
+    };
+    "duplicate-symbol": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "duplicate-suppression": {
+        readonly default: import("./types.js").CallableMessage<["code"]>;
+    };
+    "ambiguous-short-name": {
+        readonly default: import("./types.js").CallableMessage<["shortName", "candidates"]>;
+    };
+    "decorator-decl-target": {
+        readonly default: "dec must have at least one parameter.";
+        readonly required: "dec first parameter must be required.";
+    };
+    "mixed-string-template": {
+        readonly default: "String template is interpolating values and types. It must be either all values to produce a string value or or all types for string template type.";
+    };
+    "non-literal-string-template": {
+        readonly default: "Value interpolated in this string template cannot be converted to a string. Only literal types can be automatically interpolated.";
+    };
+    "ambiguous-symbol": {
+        readonly default: import("./types.js").CallableMessage<["name", "duplicateNames", "duplicateNames"]>;
+    };
+    "duplicate-using": {
+        readonly default: import("./types.js").CallableMessage<["usingName"]>;
+    };
+    "on-validate-fail": {
+        readonly default: import("./types.js").CallableMessage<["error"]>;
+    };
+    "emitter-not-found": {
+        readonly default: import("./types.js").CallableMessage<["emitterPackage", "emitterPackage"]>;
+    };
+    "invalid-emitter": {
+        readonly default: import("./types.js").CallableMessage<["emitterPackage"]>;
+    };
+    "js-error": {
+        readonly default: import("./types.js").CallableMessage<["specifier", "error"]>;
+    };
+    "missing-import": {
+        readonly default: import("./types.js").CallableMessage<["emitterName", "requiredImport", "requiredImport"]>;
+    };
+    "invalid-rule-ref": {
+        readonly default: import("./types.js").CallableMessage<["ref"]>;
+    };
+    "unknown-rule": {
+        readonly default: import("./types.js").CallableMessage<["ruleName", "libraryName"]>;
+    };
+    "unknown-rule-set": {
+        readonly default: import("./types.js").CallableMessage<["ruleSetName", "libraryName"]>;
+    };
+    "rule-enabled-disabled": {
+        readonly default: import("./types.js").CallableMessage<["ruleName"]>;
+    };
+    "invalid-rule-options": {
+        readonly default: import("./types.js").CallableMessage<["ruleName", "details"]>;
+    };
+    "circular-ruleset-file": {
+        readonly default: import("./types.js").CallableMessage<["path"]>;
+    };
+    "ruleset-file-in-library": {
+        readonly default: import("./types.js").CallableMessage<["ruleSetName", "ref"]>;
+    };
+    "format-failed": {
+        readonly default: import("./types.js").CallableMessage<["file", "details"]>;
+    };
+    "invalid-pattern-regex": {
+        readonly default: "@pattern decorator expects a valid regular expression pattern.";
+    };
+    "decorator-wrong-target": {
+        readonly default: import("./types.js").CallableMessage<["decorator", "to"]>;
+        readonly withExpected: import("./types.js").CallableMessage<["decorator", "to", "expected"]>;
+    };
+    "invalid-argument": {
+        readonly default: import("./types.js").CallableMessage<["value", "expected"]>;
+    };
+    "invalid-argument-count": {
+        readonly default: import("./types.js").CallableMessage<["expected", "actual"]>;
+        readonly atLeast: import("./types.js").CallableMessage<["expected", "actual"]>;
+    };
+    "known-values-invalid-enum": {
+        readonly default: import("./types.js").CallableMessage<["member", "type"]>;
+    };
+    "invalid-value": {
+        readonly default: import("./types.js").CallableMessage<["kind"]>;
+        readonly atPath: import("./types.js").CallableMessage<["kind", "path"]>;
+    };
+    deprecated: {
+        readonly default: import("./types.js").CallableMessage<["message"]>;
+    };
+    "no-optional-key": {
+        readonly default: import("./types.js").CallableMessage<["propertyName"]>;
+    };
+    "invalid-discriminated-union": {
+        readonly default: "";
+        readonly noAnonVariants: "Unions with anonymous variants cannot be discriminated";
+    };
+    "invalid-discriminated-union-variant": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+        readonly noEnvelopeModel: import("./types.js").CallableMessage<["name"]>;
+        readonly discriminantMismatch: import("./types.js").CallableMessage<["name", "discriminant", "propertyValue", "variantName"]>;
+        readonly duplicateDefaultVariant: import("./types.js").CallableMessage<["unionName"]>;
+        readonly noDiscriminant: import("./types.js").CallableMessage<["name", "discriminant"]>;
+        readonly wrongDiscriminantType: import("./types.js").CallableMessage<["name", "discriminant"]>;
+    };
+    "missing-discriminator-property": {
+        readonly default: import("./types.js").CallableMessage<["discriminator", "discriminator"]>;
+    };
+    "invalid-discriminator-value": {
+        readonly default: import("./types.js").CallableMessage<["kind"]>;
+        readonly required: "The discriminator property must be a required property.";
+        readonly duplicate: import("./types.js").CallableMessage<["discriminator"]>;
+    };
+    "invalid-encode": {
+        readonly default: "Invalid encoding";
+        readonly wrongType: import("./types.js").CallableMessage<["encoding", "type", "expected"]>;
+        readonly wrongEncodingType: import("./types.js").CallableMessage<["encoding", "type", "expected", "actual"]>;
+        readonly wrongNumericEncodingType: import("./types.js").CallableMessage<["encoding", "type", "expected", "actual", "expected", "encoding"]>;
+        readonly firstArg: "First argument of \"@encode\" must be the encoding name or the string type when encoding numeric or boolean types.";
+    };
+    "invalid-mime-type": {
+        readonly default: import("./types.js").CallableMessage<["mimeType"]>;
+    };
+    "no-mime-type-suffix": {
+        readonly default: import("./types.js").CallableMessage<["mimeType", "suffix"]>;
+    };
+    "encoded-name-conflict": {
+        readonly default: import("./types.js").CallableMessage<["name", "mimeType"]>;
+        readonly duplicate: import("./types.js").CallableMessage<["name", "mimeType"]>;
+    };
+    "incompatible-paging-props": {
+        readonly default: import("./types.js").CallableMessage<["kinds"]>;
+    };
+    "invalid-paging-prop": {
+        readonly default: import("./types.js").CallableMessage<["kind"]>;
+        readonly input: import("./types.js").CallableMessage<["kind"]>;
+        readonly output: import("./types.js").CallableMessage<["kind"]>;
+    };
+    "duplicate-paging-prop": {
+        readonly default: import("./types.js").CallableMessage<["kind", "operationName"]>;
+    };
+    "missing-paging-items": {
+        readonly default: import("./types.js").CallableMessage<["operationName"]>;
+    };
+    "service-decorator-duplicate": {
+        readonly default: "@service can only be set once per TypeSpec document.";
+    };
+    "list-type-not-model": {
+        readonly default: "@list decorator's parameter must be a model type.";
+    };
+    "invalid-range": {
+        readonly default: import("./types.js").CallableMessage<["start", "end"]>;
+    };
+    "add-response": {
+        readonly default: "Cannot add a response to anything except an operation statement.";
+    };
+    "add-parameter": {
+        readonly default: "Cannot add a parameter to anything except an operation statement.";
+    };
+    "add-model-property": {
+        readonly default: "Cannot add a model property to anything except a model statement.";
+    };
+    "add-model-property-fail": {
+        readonly default: import("./types.js").CallableMessage<["propertyName", "propertyTypeName"]>;
+    };
+    "add-response-type": {
+        readonly default: import("./types.js").CallableMessage<["responseTypeName", "operationName"]>;
+    };
+    "circular-base-type": {
+        readonly default: import("./types.js").CallableMessage<["typeName"]>;
+    };
+    "circular-constraint": {
+        readonly default: import("./types.js").CallableMessage<["typeName"]>;
+    };
+    "circular-op-signature": {
+        readonly default: import("./types.js").CallableMessage<["typeName"]>;
+    };
+    "circular-alias-type": {
+        readonly default: import("./types.js").CallableMessage<["typeName"]>;
+    };
+    "circular-const": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "circular-prop": {
+        readonly default: import("./types.js").CallableMessage<["propName"]>;
+    };
+    "conflict-marker": {
+        readonly default: "Conflict marker encountered.";
+    };
+    "visibility-sealed": {
+        readonly default: import("./types.js").CallableMessage<["propName"]>;
+    };
+    "default-visibility-not-member": {
+        readonly default: "The default visibility modifiers of a class must be members of the class enum.";
+    };
+    "operation-visibility-constraint-empty": {
+        readonly default: "Operation visibility constraints with no arguments are not allowed.";
+        readonly returnType: "Return type visibility constraints with no arguments are not allowed.";
+        readonly parameter: "Parameter visibility constraints with no arguments are not allowed. To disable effective PATCH optionality, use @patch(#{ implicitOptionality: false }) instead.";
+    };
+    "no-compatible-vs-installed": {
+        readonly default: "No compatible version of Visual Studio found.";
+    };
+    "vs-extension-windows-only": {
+        readonly default: "Visual Studio extension is not supported on non-Windows.";
+    };
+    "vsix-download-failed": {
+        readonly default: import("./types.js").CallableMessage<["id", "message"]>;
+    };
+    "vscode-in-path": {
+        readonly default: "Couldn't find VS Code 'code' command in PATH. Make sure you have the VS Code executable added to the system PATH.";
+        readonly osx: "Couldn't find VS Code 'code' command in PATH. Make sure you have the VS Code executable added to the system PATH.\nSee instruction for Mac OS here https://code.visualstudio.com/docs/setup/mac";
+    };
+    "invalid-option-flag": {
+        readonly default: import("./types.js").CallableMessage<["value"]>;
+    };
+    "cli-command-deprecated": {
+        readonly default: import("./types.js").CallableMessage<["command", "docsUrl"]>;
+    };
+}[C] = "default">(program: import("./program.js").Program, diag: import("./types.js").DiagnosticReport<{
+    "digit-expected": {
+        readonly default: "Digit expected.";
+    };
+    "hex-digit-expected": {
+        readonly default: "Hexadecimal digit expected.";
+    };
+    "binary-digit-expected": {
+        readonly default: "Binary digit expected.";
+    };
+    unterminated: {
+        readonly default: import("./types.js").CallableMessage<["token"]>;
+    };
+    "creating-file": {
+        readonly default: import("./types.js").CallableMessage<["filename", "error"]>;
+    };
+    "invalid-escape-sequence": {
+        readonly default: "Invalid escape sequence.";
+    };
+    "no-new-line-start-triple-quote": {
+        readonly default: "String content in triple quotes must begin on a new line.";
+    };
+    "no-new-line-end-triple-quote": {
+        readonly default: "Closing triple quotes must begin on a new line.";
+    };
+    "triple-quote-indent": {
+        readonly default: "All lines in triple-quoted string lines must have the same indentation as closing triple quotes.";
+    };
+    "invalid-character": {
+        readonly default: "Invalid character.";
+    };
+    "file-not-found": {
+        readonly default: import("./types.js").CallableMessage<["path"]>;
+    };
+    "file-load": {
+        readonly default: import("./types.js").CallableMessage<["message"]>;
+    };
+    "init-template-invalid-json": {
+        readonly default: import("./types.js").CallableMessage<["url", "message"]>;
+    };
+    "init-template-download-failed": {
+        readonly default: import("./types.js").CallableMessage<["url", "message"]>;
+    };
+    "multiple-blockless-namespace": {
+        readonly default: "Cannot use multiple blockless namespaces.";
+    };
+    "blockless-namespace-first": {
+        readonly default: "Blockless namespaces can't follow other declarations.";
+        readonly topLevel: "Blockless namespace can only be top-level.";
+    };
+    "import-first": {
+        readonly default: "Imports must come prior to namespaces or other declarations.";
+        readonly topLevel: "Imports must be top-level and come prior to namespaces or other declarations.";
+    };
+    "duplicate-import": {
+        readonly default: import("./types.js").CallableMessage<["importPath"]>;
+    };
+    "self-import": {
+        readonly default: "A file cannot import itself.";
+    };
+    "token-expected": {
+        readonly default: import("./types.js").CallableMessage<["token"]>;
+        readonly unexpected: import("./types.js").CallableMessage<["token"]>;
+        readonly numericOrStringLiteral: "Expected numeric or string literal.";
+        readonly identifier: "Identifier expected.";
+        readonly expression: "Expression expected.";
+        readonly statement: "Statement expected.";
+        readonly property: "Property expected.";
+        readonly enumMember: "Enum member expected.";
+        readonly typeofTarget: "Typeof expects a value literal or value reference.";
+    };
+    "unknown-directive": {
+        readonly default: import("./types.js").CallableMessage<["id"]>;
+    };
+    "augment-decorator-target": {
+        readonly default: "Augment decorator first argument must be a type reference.";
+        readonly noInstance: "Cannot reference template instances.";
+        readonly noModelExpression: "Cannot augment model expressions.";
+        readonly noUnionExpression: "Cannot augment union expressions.";
+    };
+    "duplicate-decorator": {
+        readonly default: import("./types.js").CallableMessage<["decoratorName"]>;
+    };
+    "decorator-conflict": {
+        readonly default: import("./types.js").CallableMessage<["decoratorName", "otherDecoratorName"]>;
+    };
+    "reserved-identifier": {
+        readonly default: "Keyword cannot be used as identifier.";
+        readonly future: import("./types.js").CallableMessage<["name"]>;
+    };
+    "invalid-directive-location": {
+        readonly default: import("./types.js").CallableMessage<["nodeName"]>;
+    };
+    "invalid-decorator-location": {
+        readonly default: import("./types.js").CallableMessage<["nodeName"]>;
+    };
+    "default-required": {
+        readonly default: "Required template parameters must not follow optional template parameters";
+    };
+    "invalid-template-argument-name": {
+        readonly default: "Template parameter argument names must be valid, bare identifiers.";
+    };
+    "invalid-template-default": {
+        readonly default: "Template parameter defaults can only reference previously declared type parameters.";
+    };
+    "required-parameter-first": {
+        readonly default: "A required parameter cannot follow an optional parameter.";
+    };
+    "rest-parameter-last": {
+        readonly default: "A rest parameter must be last in a parameter list.";
+    };
+    "rest-parameter-required": {
+        readonly default: "A rest parameter cannot be optional.";
+    };
+    "doc-invalid-identifier": {
+        readonly default: "Invalid identifier.";
+        readonly tag: "Invalid tag name. Use backticks around code if this was not meant to be a tag.";
+        readonly param: "Invalid parameter name.";
+        readonly prop: "Invalid property name.";
+        readonly templateParam: "Invalid template parameter name.";
+    };
+    "experimental-feature": {
+        readonly default: import("./types.js").CallableMessage<["feature"]>;
+        readonly functionDeclarations: "Function declarations are an experimental feature that may change in the future. Use with caution and consider providing feedback to the TypeSpec team.";
+    };
+    "union-extends-disabled": {
+        readonly default: "Union `extends` clauses require the 'union-extends' feature to be enabled. Add 'union-extends' to the 'features' list in your tspconfig.yaml.";
+    };
+    "auto-decorator-disabled": {
+        readonly default: "Auto decorator declarations require the 'auto-decorators' feature to be enabled. Add 'auto-decorators' to the 'features' list in your tspconfig.yaml.";
+    };
+    "using-invalid-ref": {
+        readonly default: "Using must refer to a namespace";
+    };
+    "invalid-type-ref": {
+        readonly default: "Invalid type reference";
+        readonly decorator: "Can't put a decorator in a type";
+        readonly function: "Can't use a function as a type";
+    };
+    "invalid-template-args": {
+        readonly default: "Invalid template arguments.";
+        readonly notTemplate: "Can't pass template arguments to non-templated type";
+        readonly tooMany: "Too many template arguments provided.";
+        readonly unknownName: import("./types.js").CallableMessage<["name"]>;
+        readonly positionalAfterNamed: "Positional template arguments cannot follow named arguments in the same argument list.";
+        readonly missing: import("./types.js").CallableMessage<["name"]>;
+        readonly specifiedAgain: import("./types.js").CallableMessage<["name"]>;
+    };
+    "intersect-non-model": {
+        readonly default: "Cannot intersect non-model types (including union types).";
+    };
+    "intersect-invalid-index": {
+        readonly default: "Cannot intersect incompatible models.";
+        readonly never: "Cannot intersect a model that cannot hold properties.";
+        readonly array: "Cannot intersect an array model.";
+    };
+    "incompatible-indexer": {
+        readonly default: import("./types.js").CallableMessage<["message"]>;
+    };
+    "no-array-properties": {
+        readonly default: "Array models cannot have any properties.";
+    };
+    "intersect-duplicate-property": {
+        readonly default: import("./types.js").CallableMessage<["propName"]>;
+    };
+    "invalid-decorator": {
+        readonly default: import("./types.js").CallableMessage<["id"]>;
+    };
+    "invalid-ref": {
+        readonly default: import("./types.js").CallableMessage<["id"]>;
+        readonly identifier: import("./types.js").CallableMessage<["id"]>;
+        readonly decorator: import("./types.js").CallableMessage<["id"]>;
+        readonly inDecorator: import("./types.js").CallableMessage<["id"]>;
+        readonly underNamespace: import("./types.js").CallableMessage<["namespace", "id"]>;
+        readonly member: import("./types.js").CallableMessage<["kind", "id"]>;
+        readonly metaProperty: import("./types.js").CallableMessage<["kind", "id"]>;
+        readonly node: import("./types.js").CallableMessage<["id", "nodeName"]>;
+        readonly internal: import("./types.js").CallableMessage<["id"]>;
+    };
+    "duplicate-property": {
+        readonly default: import("./types.js").CallableMessage<["propName"]>;
+        readonly withModel: import("./types.js").CallableMessage<["modelName", "propName"]>;
+    };
+    "override-property-mismatch": {
+        readonly default: import("./types.js").CallableMessage<["propName", "propType", "parentType"]>;
+        readonly disallowedOptionalOverride: import("./types.js").CallableMessage<["propName"]>;
+    };
+    "extend-scalar": {
+        readonly default: "Scalar must extend other scalars.";
+    };
+    "extend-model": {
+        readonly default: "Models must extend other models.";
+        readonly modelExpression: "Models cannot extend model expressions.";
+    };
+    "extend-union": {
+        readonly default: "Union `extends` must specify a model, scalar, enum, or union.";
+        readonly modelExpression: "Unions cannot extend model expressions.";
+    };
+    "is-model": {
+        readonly default: "Model `is` must specify another model.";
+        readonly modelExpression: "Model `is` cannot specify a model expression.";
+    };
+    "is-operation": {
+        readonly default: "Operation can only reuse the signature of another operation.";
+    };
+    "spread-model": {
+        readonly default: "Cannot spread properties of non-model type.";
+        readonly neverIndex: "Cannot spread type because it cannot hold properties.";
+        readonly selfSpread: "Cannot spread type within its own declaration.";
+    };
+    "unsupported-default": {
+        readonly default: import("./types.js").CallableMessage<["type"]>;
+    };
+    "spread-object": {
+        readonly default: "Cannot spread properties of non-object type.";
+    };
+    "expect-value": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+        readonly model: import("./types.js").CallableMessage<["name"]>;
+        readonly modelExpression: "Is a model expression type, but is being used as a value here. Use #{} to create an object value.";
+        readonly tuple: "Is a tuple type, but is being used as a value here. Use #[] to create an array value.";
+        readonly templateConstraint: import("./types.js").CallableMessage<["name"]>;
+        readonly functionReturn: import("./types.js").CallableMessage<[]>;
+    };
+    "non-callable": {
+        readonly default: import("./types.js").CallableMessage<["type"]>;
+        readonly templateParameter: import("./types.js").CallableMessage<["name", "constraint"]>;
+    };
+    "named-init-required": {
+        readonly default: import("./types.js").CallableMessage<[]>;
+    };
+    "invalid-primitive-init": {
+        readonly default: "Instantiating scalar deriving from 'string', 'numeric' or 'boolean' can only take a single argument.";
+        readonly invalidArg: import("./types.js").CallableMessage<["expected", "actual"]>;
+    };
+    "ambiguous-scalar-type": {
+        readonly default: import("./types.js").CallableMessage<["value", "types", "example", "value"]>;
+    };
+    unassignable: {
+        readonly default: import("./types.js").CallableMessage<["sourceType", "targetType"]>;
+    };
+    "property-unassignable": {
+        readonly default: import("./types.js").CallableMessage<["propName"]>;
+    };
+    "property-required": {
+        readonly default: import("./types.js").CallableMessage<["propName", "targetType"]>;
+    };
+    "parameter-required": {
+        readonly default: import("./types.js").CallableMessage<["paramName"]>;
+        readonly missing: import("./types.js").CallableMessage<["paramName"]>;
+        readonly "rest-to-required": import("./types.js").CallableMessage<["paramName"]>;
+    };
+    "value-in-type": {
+        readonly default: "A value cannot be used as a type.";
+        readonly referenceTemplate: "Template parameter can be passed values but is used as a type.";
+        readonly noTemplateConstraint: "Template parameter has no constraint but a value is passed. Add `extends valueof unknown` to accept any value.";
+    };
+    "no-prop": {
+        readonly default: import("./types.js").CallableMessage<["propName"]>;
+    };
+    "missing-index": {
+        readonly default: import("./types.js").CallableMessage<["indexType", "sourceType"]>;
+    };
+    "missing-property": {
+        readonly default: import("./types.js").CallableMessage<["propertyName", "sourceType", "targetType"]>;
+    };
+    "unexpected-property": {
+        readonly default: import("./types.js").CallableMessage<["propertyName", "type"]>;
+    };
+    "extends-interface": {
+        readonly default: "Interfaces can only extend other interfaces";
+    };
+    "extends-interface-duplicate": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "interface-duplicate": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "union-duplicate": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "enum-member-duplicate": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "constructor-duplicate": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "spread-enum": {
+        readonly default: "Cannot spread members of non-enum type.";
+    };
+    "decorator-fail": {
+        readonly default: import("./types.js").CallableMessage<["decoratorName", "error"]>;
+    };
+    "rest-parameter-array": {
+        readonly default: "A rest parameter must be of an array type.";
+    };
+    "invalid-modifier": {
+        readonly default: import("./types.js").CallableMessage<["modifier"]>;
+        readonly "missing-required": import("./types.js").CallableMessage<["nodeKind", "modifier"]>;
+        readonly "missing-required-one-of": import("./types.js").CallableMessage<["nodeKind", "modifiers"]>;
+        readonly "mutually-exclusive": import("./types.js").CallableMessage<["modifierA", "modifierB"]>;
+        readonly "not-allowed": import("./types.js").CallableMessage<["modifier", "nodeKind"]>;
+    };
+    "function-return": {
+        readonly default: "Function implementation returned an invalid result.";
+        readonly "invalid-value": import("./types.js").CallableMessage<["value"]>;
+        readonly unassignable: import("./types.js").CallableMessage<["name", "entityKind", "return", "type"]>;
+    };
+    "fn-in-union-expression": {
+        readonly default: "Function types in anonymous union expressions must be parenthesized.";
+    };
+    "missing-implementation": {
+        readonly default: "Extern declaration must have an implementation in JS file.";
+    };
+    "missing-extern-declaration": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "overload-same-parent": {
+        readonly default: "Overload must be in the same interface or namespace.";
+    };
+    shadow: {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "invalid-deprecation-argument": {
+        readonly default: import("./types.js").CallableMessage<["kind"]>;
+        readonly missing: "#deprecation directive is expecting a message argument but none was provided.";
+    };
+    "duplicate-deprecation": {
+        readonly default: "The #deprecated directive cannot be used more than once on the same declaration.";
+    };
+    "config-invalid-argument": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "config-circular-variable": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "config-path-absolute": {
+        readonly default: import("./types.js").CallableMessage<["path"]>;
+    };
+    "config-invalid-name": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "path-unix-style": {
+        readonly default: import("./types.js").CallableMessage<[]>;
+    };
+    "config-path-not-found": {
+        readonly default: import("./types.js").CallableMessage<["path"]>;
+    };
+    "config-project-kind-filename": {
+        readonly default: import("./types.js").CallableMessage<["filename"]>;
+    };
+    "config-project-only-option": {
+        readonly default: import("./types.js").CallableMessage<["option"]>;
+    };
+    "config-unknown-feature": {
+        readonly default: import("./types.js").CallableMessage<["feature"]>;
+    };
+    "config-project-not-as-cli-config": {
+        readonly default: "`--config` cannot point to a project config (with `kind: project`). Use a non-project build config that `extends` the project config instead.";
+    };
+    "dynamic-import": {
+        readonly default: "Dynamically generated TypeSpec cannot have imports";
+    };
+    "invalid-import": {
+        readonly default: "Import paths must reference either a directory, a .tsp file, or .js file";
+    };
+    "invalid-main": {
+        readonly default: "Main file must either be a .tsp file or a .js file.";
+    };
+    "import-not-found": {
+        readonly default: import("./types.js").CallableMessage<["path"]>;
+    };
+    "library-invalid": {
+        readonly default: import("./types.js").CallableMessage<["path", "message"]>;
+    };
+    "incompatible-library": {
+        readonly default: import("./types.js").CallableMessage<["name", "versionMap"]>;
+    };
+    "compiler-version-mismatch": {
+        readonly default: import("./types.js").CallableMessage<["basedir", "basedir", "betterTypeSpecServerPath", "expected", "actual"]>;
+    };
+    "duplicate-symbol": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "duplicate-suppression": {
+        readonly default: import("./types.js").CallableMessage<["code"]>;
+    };
+    "ambiguous-short-name": {
+        readonly default: import("./types.js").CallableMessage<["shortName", "candidates"]>;
+    };
+    "decorator-decl-target": {
+        readonly default: "dec must have at least one parameter.";
+        readonly required: "dec first parameter must be required.";
+    };
+    "mixed-string-template": {
+        readonly default: "String template is interpolating values and types. It must be either all values to produce a string value or or all types for string template type.";
+    };
+    "non-literal-string-template": {
+        readonly default: "Value interpolated in this string template cannot be converted to a string. Only literal types can be automatically interpolated.";
+    };
+    "ambiguous-symbol": {
+        readonly default: import("./types.js").CallableMessage<["name", "duplicateNames", "duplicateNames"]>;
+    };
+    "duplicate-using": {
+        readonly default: import("./types.js").CallableMessage<["usingName"]>;
+    };
+    "on-validate-fail": {
+        readonly default: import("./types.js").CallableMessage<["error"]>;
+    };
+    "emitter-not-found": {
+        readonly default: import("./types.js").CallableMessage<["emitterPackage", "emitterPackage"]>;
+    };
+    "invalid-emitter": {
+        readonly default: import("./types.js").CallableMessage<["emitterPackage"]>;
+    };
+    "js-error": {
+        readonly default: import("./types.js").CallableMessage<["specifier", "error"]>;
+    };
+    "missing-import": {
+        readonly default: import("./types.js").CallableMessage<["emitterName", "requiredImport", "requiredImport"]>;
+    };
+    "invalid-rule-ref": {
+        readonly default: import("./types.js").CallableMessage<["ref"]>;
+    };
+    "unknown-rule": {
+        readonly default: import("./types.js").CallableMessage<["ruleName", "libraryName"]>;
+    };
+    "unknown-rule-set": {
+        readonly default: import("./types.js").CallableMessage<["ruleSetName", "libraryName"]>;
+    };
+    "rule-enabled-disabled": {
+        readonly default: import("./types.js").CallableMessage<["ruleName"]>;
+    };
+    "invalid-rule-options": {
+        readonly default: import("./types.js").CallableMessage<["ruleName", "details"]>;
+    };
+    "circular-ruleset-file": {
+        readonly default: import("./types.js").CallableMessage<["path"]>;
+    };
+    "ruleset-file-in-library": {
+        readonly default: import("./types.js").CallableMessage<["ruleSetName", "ref"]>;
+    };
+    "format-failed": {
+        readonly default: import("./types.js").CallableMessage<["file", "details"]>;
+    };
+    "invalid-pattern-regex": {
+        readonly default: "@pattern decorator expects a valid regular expression pattern.";
+    };
+    "decorator-wrong-target": {
+        readonly default: import("./types.js").CallableMessage<["decorator", "to"]>;
+        readonly withExpected: import("./types.js").CallableMessage<["decorator", "to", "expected"]>;
+    };
+    "invalid-argument": {
+        readonly default: import("./types.js").CallableMessage<["value", "expected"]>;
+    };
+    "invalid-argument-count": {
+        readonly default: import("./types.js").CallableMessage<["expected", "actual"]>;
+        readonly atLeast: import("./types.js").CallableMessage<["expected", "actual"]>;
+    };
+    "known-values-invalid-enum": {
+        readonly default: import("./types.js").CallableMessage<["member", "type"]>;
+    };
+    "invalid-value": {
+        readonly default: import("./types.js").CallableMessage<["kind"]>;
+        readonly atPath: import("./types.js").CallableMessage<["kind", "path"]>;
+    };
+    deprecated: {
+        readonly default: import("./types.js").CallableMessage<["message"]>;
+    };
+    "no-optional-key": {
+        readonly default: import("./types.js").CallableMessage<["propertyName"]>;
+    };
+    "invalid-discriminated-union": {
+        readonly default: "";
+        readonly noAnonVariants: "Unions with anonymous variants cannot be discriminated";
+    };
+    "invalid-discriminated-union-variant": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+        readonly noEnvelopeModel: import("./types.js").CallableMessage<["name"]>;
+        readonly discriminantMismatch: import("./types.js").CallableMessage<["name", "discriminant", "propertyValue", "variantName"]>;
+        readonly duplicateDefaultVariant: import("./types.js").CallableMessage<["unionName"]>;
+        readonly noDiscriminant: import("./types.js").CallableMessage<["name", "discriminant"]>;
+        readonly wrongDiscriminantType: import("./types.js").CallableMessage<["name", "discriminant"]>;
+    };
+    "missing-discriminator-property": {
+        readonly default: import("./types.js").CallableMessage<["discriminator", "discriminator"]>;
+    };
+    "invalid-discriminator-value": {
+        readonly default: import("./types.js").CallableMessage<["kind"]>;
+        readonly required: "The discriminator property must be a required property.";
+        readonly duplicate: import("./types.js").CallableMessage<["discriminator"]>;
+    };
+    "invalid-encode": {
+        readonly default: "Invalid encoding";
+        readonly wrongType: import("./types.js").CallableMessage<["encoding", "type", "expected"]>;
+        readonly wrongEncodingType: import("./types.js").CallableMessage<["encoding", "type", "expected", "actual"]>;
+        readonly wrongNumericEncodingType: import("./types.js").CallableMessage<["encoding", "type", "expected", "actual", "expected", "encoding"]>;
+        readonly firstArg: "First argument of \"@encode\" must be the encoding name or the string type when encoding numeric or boolean types.";
+    };
+    "invalid-mime-type": {
+        readonly default: import("./types.js").CallableMessage<["mimeType"]>;
+    };
+    "no-mime-type-suffix": {
+        readonly default: import("./types.js").CallableMessage<["mimeType", "suffix"]>;
+    };
+    "encoded-name-conflict": {
+        readonly default: import("./types.js").CallableMessage<["name", "mimeType"]>;
+        readonly duplicate: import("./types.js").CallableMessage<["name", "mimeType"]>;
+    };
+    "incompatible-paging-props": {
+        readonly default: import("./types.js").CallableMessage<["kinds"]>;
+    };
+    "invalid-paging-prop": {
+        readonly default: import("./types.js").CallableMessage<["kind"]>;
+        readonly input: import("./types.js").CallableMessage<["kind"]>;
+        readonly output: import("./types.js").CallableMessage<["kind"]>;
+    };
+    "duplicate-paging-prop": {
+        readonly default: import("./types.js").CallableMessage<["kind", "operationName"]>;
+    };
+    "missing-paging-items": {
+        readonly default: import("./types.js").CallableMessage<["operationName"]>;
+    };
+    "service-decorator-duplicate": {
+        readonly default: "@service can only be set once per TypeSpec document.";
+    };
+    "list-type-not-model": {
+        readonly default: "@list decorator's parameter must be a model type.";
+    };
+    "invalid-range": {
+        readonly default: import("./types.js").CallableMessage<["start", "end"]>;
+    };
+    "add-response": {
+        readonly default: "Cannot add a response to anything except an operation statement.";
+    };
+    "add-parameter": {
+        readonly default: "Cannot add a parameter to anything except an operation statement.";
+    };
+    "add-model-property": {
+        readonly default: "Cannot add a model property to anything except a model statement.";
+    };
+    "add-model-property-fail": {
+        readonly default: import("./types.js").CallableMessage<["propertyName", "propertyTypeName"]>;
+    };
+    "add-response-type": {
+        readonly default: import("./types.js").CallableMessage<["responseTypeName", "operationName"]>;
+    };
+    "circular-base-type": {
+        readonly default: import("./types.js").CallableMessage<["typeName"]>;
+    };
+    "circular-constraint": {
+        readonly default: import("./types.js").CallableMessage<["typeName"]>;
+    };
+    "circular-op-signature": {
+        readonly default: import("./types.js").CallableMessage<["typeName"]>;
+    };
+    "circular-alias-type": {
+        readonly default: import("./types.js").CallableMessage<["typeName"]>;
+    };
+    "circular-const": {
+        readonly default: import("./types.js").CallableMessage<["name"]>;
+    };
+    "circular-prop": {
+        readonly default: import("./types.js").CallableMessage<["propName"]>;
+    };
+    "conflict-marker": {
+        readonly default: "Conflict marker encountered.";
+    };
+    "visibility-sealed": {
+        readonly default: import("./types.js").CallableMessage<["propName"]>;
+    };
+    "default-visibility-not-member": {
+        readonly default: "The default visibility modifiers of a class must be members of the class enum.";
+    };
+    "operation-visibility-constraint-empty": {
+        readonly default: "Operation visibility constraints with no arguments are not allowed.";
+        readonly returnType: "Return type visibility constraints with no arguments are not allowed.";
+        readonly parameter: "Parameter visibility constraints with no arguments are not allowed. To disable effective PATCH optionality, use @patch(#{ implicitOptionality: false }) instead.";
+    };
+    "no-compatible-vs-installed": {
+        readonly default: "No compatible version of Visual Studio found.";
+    };
+    "vs-extension-windows-only": {
+        readonly default: "Visual Studio extension is not supported on non-Windows.";
+    };
+    "vsix-download-failed": {
+        readonly default: import("./types.js").CallableMessage<["id", "message"]>;
+    };
+    "vscode-in-path": {
+        readonly default: "Couldn't find VS Code 'code' command in PATH. Make sure you have the VS Code executable added to the system PATH.";
+        readonly osx: "Couldn't find VS Code 'code' command in PATH. Make sure you have the VS Code executable added to the system PATH.\nSee instruction for Mac OS here https://code.visualstudio.com/docs/setup/mac";
+    };
+    "invalid-option-flag": {
+        readonly default: import("./types.js").CallableMessage<["value"]>;
+    };
+    "cli-command-deprecated": {
+        readonly default: import("./types.js").CallableMessage<["command", "docsUrl"]>;
+    };
+}, C, M>) => void;
+export {};
+//# sourceMappingURL=messages.d.ts.map