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

package/libexec/authoring/node_modules/@typespec/compiler/dist/src/lib/decorators.js

@@ -0,0 +1,915 @@
+import { getPropertyType, validateDecoratorNotOnType, validateDecoratorUniqueOnNode, } from "../core/decorator-utils.js";
+import { getDeprecationDetails } from "../core/deprecation.js";
+import { compilerAssert, ignoreDiagnostics } from "../core/diagnostics.js";
+import { getDiscriminatedUnion } from "../core/helpers/discriminator-utils.js";
+import { getTypeName } from "../core/helpers/type-name-utils.js";
+import { getDocDataInternal, getMaxItemsAsNumeric, getMaxLengthAsNumeric, getMaxValueAsNumeric, getMaxValueExclusiveAsNumeric, getMinItemsAsNumeric, getMinLengthAsNumeric, getMinValueAsNumeric, getMinValueExclusiveAsNumeric, setDiscriminatedOptions, setDiscriminator, setDocData, setMaxItems, setMaxLength, setMaxValue, setMaxValueExclusive, setMinItems, setMinLength, setMinValue, setMinValueExclusive, } from "../core/intrinsic-type-state.js";
+import { reportDiagnostic } from "../core/messages.js";
+import { parseMimeType } from "../core/mime-type.js";
+import { isNumeric } from "../core/numeric.js";
+import { isArrayModelType, isValue } from "../core/type-utils.js";
+import { SyntaxKind } from "../core/types.js";
+import { Realm } from "../experimental/realm.js";
+import { $ } from "../typekit/index.js";
+import { useStateMap, useStateSet } from "../utils/index.js";
+import { setKey } from "./key.js";
+import { createStateSymbol, filterModelPropertiesInPlace, replaceTemplatedStringFromProperties, } from "./utils.js";
+export { $encodedName, resolveEncodedName } from "./encoded-names.js";
+export { serializeValueAsJson } from "./examples.js";
+export { getPagingOperation, isList } from "./paging.js";
+export * from "./service.js";
+export * from "./visibility.js";
+export const namespace = "TypeSpec";
+const [getSummary, setSummary] = useStateMap(createStateSymbol("summary"));
+/**
+ * @summary attaches a documentation string. It is typically used to give a short, single-line
+ * description, and can be used in combination with or instead of @doc.
+ *
+ * The first argument to @summary is a string, which may contain template parameters, enclosed in braces,
+ * which are replaced with an attribute for the type (commonly "name") passed as the second (optional) argument.
+ *
+ * @summary can be specified on any language element -- a model, an operation, a namespace, etc.
+ */
+export const $summary = (context, target, text, sourceObject) => {
+    if (sourceObject) {
+        text = replaceTemplatedStringFromProperties(text, sourceObject);
+    }
+    setSummary(context.program, target, text);
+};
+export { getSummary };
+/**
+ * `@doc` attaches a documentation string. Works great with multi-line string literals.
+ *
+ * The first argument to `@doc` is a string, which may contain template parameters, enclosed in braces,
+ * which are replaced with an attribute for the type (commonly "name") passed as the second (optional) argument.
+ *
+ * `@doc` can be specified on any language element -- a model, an operation, a namespace, etc.
+ */
+export const $doc = (context, target, text, sourceObject) => {
+    validateDecoratorUniqueOnNode(context, target, $doc);
+    if (sourceObject) {
+        text = replaceTemplatedStringFromProperties(text, sourceObject);
+    }
+    setDocData(context.program, target, "self", { value: text, source: "decorator" });
+};
+/**
+ * Get the documentation string for the given type.
+ * @param program Program
+ * @param target Type
+ * @returns Documentation value
+ */
+export function getDoc(program, target) {
+    return getDocDataInternal(program, target, "self")?.value;
+}
+export const $returnsDoc = (context, target, text) => {
+    validateDecoratorUniqueOnNode(context, target, $doc);
+    setDocData(context.program, target, "returns", { value: text, source: "decorator" });
+};
+/**
+ * Get the documentation information for the return success types of an operation. In most cases you probably just want to use {@link getReturnsDoc}
+ * @param program Program
+ * @param target Type
+ * @returns Doc data with source information.
+ */
+export function getReturnsDocData(program, target) {
+    return getDocDataInternal(program, target, "returns");
+}
+/**
+ * Get the documentation string for the return success types of an operation.
+ * @param program Program
+ * @param target Type
+ * @returns Documentation value
+ */
+export function getReturnsDoc(program, target) {
+    return getDocDataInternal(program, target, "returns")?.value;
+}
+export const $errorsDoc = (context, target, text) => {
+    validateDecoratorUniqueOnNode(context, target, $doc);
+    setDocData(context.program, target, "errors", { value: text, source: "decorator" });
+};
+/**
+ * Get the documentation information for the return errors types of an operation. In most cases you probably just want to use {@link getErrorsDoc}
+ * @param program Program
+ * @param target Type
+ * @returns Doc data with source information.
+ */
+export function getErrorsDocData(program, target) {
+    return getDocDataInternal(program, target, "errors");
+}
+/**
+ * Get the documentation string for the return errors types of an operation.
+ * @param program Program
+ * @param target Type
+ * @returns Documentation value
+ */
+export function getErrorsDoc(program, target) {
+    return getDocDataInternal(program, target, "errors")?.value;
+}
+export const $inspectType = (context, target, text) => {
+    // eslint-disable-next-line no-console
+    if (text)
+        console.log(text);
+    // eslint-disable-next-line no-console
+    console.dir(target, { depth: 3 });
+};
+export const $inspectTypeName = (context, target, text) => {
+    // eslint-disable-next-line no-console
+    if (text)
+        console.log(text);
+    // eslint-disable-next-line no-console
+    console.log(getTypeName(target));
+};
+export function isStringType(program, target) {
+    const stringType = program.checker.getStdType("string");
+    return (target.kind === "Scalar" && program.checker.isTypeAssignableTo(target, stringType, target)[0]);
+}
+export function isNumericType(program, target) {
+    const numericType = program.checker.getStdType("numeric");
+    return (target.kind === "Scalar" && program.checker.isTypeAssignableTo(target, numericType, target)[0]);
+}
+export function isDateTimeType(program, target) {
+    if (target.kind !== "Scalar") {
+        return false;
+    }
+    const dateTimeTypes = [
+        "utcDateTime",
+        "offsetDateTime",
+        "plainDate",
+        "plainTime",
+        "duration",
+    ];
+    return dateTimeTypes.some((typeName) => {
+        const stdType = program.checker.getStdType(typeName);
+        return program.checker.isTypeAssignableTo(target, stdType, target)[0];
+    });
+}
+/**
+ * Check the given type is matching the given condition or is a union of null and types matching the condition.
+ * @param type Type to test
+ * @param condition Condition
+ * @returns Boolean
+ */
+function isTypeIn(type, condition) {
+    if (type.kind === "Union") {
+        return [...type.variants.values()].some((v) => condition(v.type));
+    }
+    return condition(type);
+}
+/**
+ * Validate the target is a comparable type (numeric or datetime) that supports min/max value constraints.
+ * @param context Decorator context
+ * @param target Target type to validate
+ * @param decoratorName Name of the decorator for error reporting
+ * @returns True if target is valid, false otherwise
+ */
+function validateTargetingComparableType(context, target, decoratorName) {
+    const valid = isTypeIn(getPropertyType(target), (x) => isNumericType(context.program, x) || isDateTimeType(context.program, x));
+    if (!valid) {
+        reportDiagnostic(context.program, {
+            code: "decorator-wrong-target",
+            format: {
+                decorator: decoratorName,
+                to: `type it must be a numeric or comparable type`,
+            },
+            target: context.decoratorTarget,
+        });
+    }
+    return valid;
+}
+/**
+ * Validate that the value passed to a min/max decorator is assignable to the target type.
+ * @param context Decorator context
+ * @param target Target type
+ * @param value Value to validate
+ * @returns True if value is compatible, false otherwise
+ */
+function validateValueAssignableToTarget(context, target, value) {
+    const targetType = getPropertyType(target);
+    if (isNumeric(value)) {
+        value = $(context.program).value.createNumeric(value);
+    }
+    const [assignable, diagnostics] = $(context.program).value.isOfType.withDiagnostics(value, targetType, context.getArgumentTarget(0));
+    if (!assignable) {
+        context.program.reportDiagnostics(diagnostics);
+    }
+    return assignable;
+}
+/**
+ * Validate the given target is a string type or a union containing at least a string type.
+ */
+function validateTargetingAString(context, target, decoratorName) {
+    const propertyType = getPropertyType(target);
+    const valid = isTypeIn(propertyType, (x) => isStringType(context.program, x));
+    if (!valid) {
+        reportDiagnostic(context.program, {
+            code: "decorator-wrong-target",
+            format: {
+                decorator: decoratorName,
+                to: propertyType.kind === "Union"
+                    ? `a union type that is not string compatible. The union must explicitly include a string type, and all union values should be strings. For example: union Test { string, "A", "B" }`
+                    : `type it is not a string`,
+            },
+            target: context.decoratorTarget,
+        });
+    }
+    return valid;
+}
+/**
+ * Get the actual type from a Type or ModelProperty for array validation
+ */
+function getTypeForArrayValidation(target) {
+    if (target.kind === "ModelProperty") {
+        return target.type;
+    }
+    else {
+        return target.kind === "Model" ? target : target.type;
+    }
+}
+/**
+ * Validate the given target is an array type or a union containing at least an array type.
+ */
+function validateTargetingAnArray(context, target, decoratorName) {
+    const targetType = getTypeForArrayValidation(target);
+    const valid = isTypeIn(targetType, (x) => x.kind === "Model" && isArrayModelType(x));
+    if (!valid) {
+        reportDiagnostic(context.program, {
+            code: "decorator-wrong-target",
+            format: {
+                decorator: decoratorName,
+                to: `non Array type`,
+            },
+            target: context.decoratorTarget,
+        });
+    }
+    return valid;
+}
+// -- @error decorator ----------------------
+const [getErrorState, setErrorState] = useStateSet(createStateSymbol("error"));
+/**
+ * `@error` decorator marks a model as an error type.
+ *  Any derived models (using extends) will also be seen as error types.
+ */
+export const $error = (context, entity) => {
+    validateDecoratorUniqueOnNode(context, entity, $error);
+    setErrorState(context.program, entity);
+};
+/**
+ * Check if the type is an error model or a descendant of an error model.
+ */
+export function isErrorModel(program, target) {
+    if (target.kind !== "Model") {
+        return false;
+    }
+    let current = target;
+    while (current) {
+        if (getErrorState(program, current)) {
+            return true;
+        }
+        current = current.baseModel;
+    }
+    return false;
+}
+// -- @mediaTypeHint decorator --------------
+const [_getMediaTypeHint, _setMediaTypeHint] = useStateMap(createStateSymbol("mediaTypeHint"));
+export const $mediaTypeHint = (context, target, mediaType) => {
+    validateDecoratorUniqueOnNode(context, target, $mediaTypeHint);
+    const mimeTypeObj = parseMimeType(mediaType);
+    if (mimeTypeObj === undefined) {
+        reportDiagnostic(context.program, {
+            code: "invalid-mime-type",
+            format: { mimeType: mediaType },
+            target: context.getArgumentTarget(0),
+        });
+    }
+    _setMediaTypeHint(context.program, target, mediaType);
+};
+/**
+ * Sets the default media type hint for the given target type.
+ *
+ * This value is a hint _ONLY_. Emitters are not required to use it, but may use it to get the default media type
+ * associated with a TypeSpec type.
+ *
+ * If a type already has a default media type hint set, this function will override it with the new value.
+ *
+ * WARNING: this function _will throw an error_ if the provided media type string is not recognized as a valid
+ * MIME type.
+ *
+ * @param program - the Program containing the target
+ * @param target - the target to set the MIME type hint for
+ * @param mediaType - the default media type hint to set for the target
+ * @throws if the provided media type string is not recognized as a valid MIME type
+ */
+export function setMediaTypeHint(program, target, mediaType) {
+    const mimeTypeObj = parseMimeType(mediaType);
+    compilerAssert(mimeTypeObj !== undefined, `Invalid MIME type '${mediaType}' provided to setMediaTypeHint`);
+    _setMediaTypeHint(program, target, mediaType);
+}
+/**
+ * Get the default media type hint for the given target type.
+ *
+ * This value is a hint _ONLY_. Emitters are not required to use it, but may use it to get the default media type
+ * associated with a TypeSpec type.
+ *
+ * @param program - the Program containing the target
+ * @param target - the target to get the MIME type for
+ * @returns the default media type hint for the target, if any
+ */
+export function getMediaTypeHint(program, target) {
+    switch (target.kind) {
+        case "Scalar":
+            // This special-casing is necessary because we cannot apply a decorator with a `valueof string` argument to
+            // `string` itself. It creates a circular dependency in the checker where initializing the decorator value depends
+            // on `string` already being initialized, which it isn't if we're still checking its decorators. This simple
+            // special-casing allows us to avoid that circularity or having to special-case the initialization of string
+            // itself.
+            const isTypeSpecString = target.name === "string" &&
+                target.namespace?.name === "TypeSpec" &&
+                target.namespace.namespace === program.getGlobalNamespaceType();
+            if (isTypeSpecString)
+                return "text/plain";
+        // Intentional fallthrough
+        // eslint-disable-next-line no-fallthrough
+        case "Union":
+        case "Enum":
+        case "Model": {
+            // Assert this satisfies clause to make sure we've handled everything that is MimeTypeable
+            void 0;
+            const hint = _getMediaTypeHint(program, target);
+            if (!hint) {
+                // Look up the hierarchy for a MIME type hint if we don't have one on this type.
+                const ancestor = target.kind === "Model"
+                    ? target.baseModel
+                    : target.kind === "Scalar"
+                        ? target.baseScalar
+                        : undefined;
+                if (ancestor) {
+                    return getMediaTypeHint(program, ancestor);
+                }
+            }
+            return hint;
+        }
+        default:
+            return undefined;
+    }
+}
+// -- @format decorator ---------------------
+const [getFormat, setFormat] = useStateMap(createStateSymbol("format"));
+/**
+ * `@format` - specify the data format hint for a string type
+ *
+ * The first argument is a string that identifies the format that the string type expects.  Any string
+ * can be entered here, but a TypeSpec emitter must know how to interpret
+ *
+ * For TypeSpec specs that will be used with an OpenAPI emitter, the OpenAPI specification describes possible
+ * valid values for a string type's format:
+ *
+ * https://github.com/OAI/OpenAPI-Specification/blob/3.0.3/versions/3.0.3.md#dataTypes
+ *
+ * `@format` can be specified on a type that extends from `string` or a `string`-typed model property.
+ */
+export const $format = (context, target, format) => {
+    validateDecoratorUniqueOnNode(context, target, $format);
+    if (!validateTargetingAString(context, target, "@format")) {
+        return;
+    }
+    setFormat(context.program, target, format);
+};
+export { getFormat };
+// -- @pattern decorator ---------------------
+const [getPatternData, setPatternData] = useStateMap(createStateSymbol("patternValues"));
+export const $pattern = (context, target, pattern, validationMessage) => {
+    validateDecoratorUniqueOnNode(context, target, $pattern);
+    if (!validateTargetingAString(context, target, "@pattern")) {
+        return;
+    }
+    try {
+        new RegExp(pattern);
+    }
+    catch (e) {
+        reportDiagnostic(context.program, {
+            code: "invalid-pattern-regex",
+            target: target,
+        });
+    }
+    const patternData = {
+        pattern,
+        validationMessage,
+    };
+    setPatternData(context.program, target, patternData);
+};
+/**
+ * Gets the pattern regular expression associated with a given type, if one has been set.
+ *
+ * @see getPatternData
+ *
+ * @param program - the Program containing the target Type
+ * @param target - the type to get the pattern for
+ * @returns the pattern string, if one was set
+ */
+export function getPattern(program, target) {
+    return getPatternData(program, target)?.pattern;
+}
+export { 
+/**
+ * Gets the associated pattern data, including the pattern regular expression and optional validation message, if any
+ * has been set.
+ *
+ * @param program - the Program containing the target Type
+ * @param target - the type to get the pattern data for
+ * @returns the pattern data, if any was set
+ */
+getPatternData, };
+// -- @minLength decorator ---------------------
+export const $minLength = (context, target, minLength) => {
+    validateDecoratorUniqueOnNode(context, target, $minLength);
+    if (!validateTargetingAString(context, target, "@minLength") ||
+        !validateRange(context, minLength, getMaxLengthAsNumeric(context.program, target))) {
+        return;
+    }
+    setMinLength(context.program, target, minLength);
+};
+// -- @maxLength decorator ---------------------
+export const $maxLength = (context, target, maxLength) => {
+    validateDecoratorUniqueOnNode(context, target, $maxLength);
+    if (!validateTargetingAString(context, target, "@maxLength") ||
+        !validateRange(context, getMinLengthAsNumeric(context.program, target), maxLength)) {
+        return;
+    }
+    setMaxLength(context.program, target, maxLength);
+};
+// -- @minItems decorator ---------------------
+export const $minItems = (context, target, minItems) => {
+    validateDecoratorUniqueOnNode(context, target, $minItems);
+    if (!validateTargetingAnArray(context, target, "@minItems")) {
+        return;
+    }
+    if (!validateRange(context, minItems, getMaxItemsAsNumeric(context.program, target))) {
+        return;
+    }
+    setMinItems(context.program, target, minItems);
+};
+// -- @maxLength decorator ---------------------
+export const $maxItems = (context, target, maxItems) => {
+    validateDecoratorUniqueOnNode(context, target, $maxItems);
+    if (!validateTargetingAnArray(context, target, "@maxItems")) {
+        return;
+    }
+    if (!validateRange(context, getMinItemsAsNumeric(context.program, target), maxItems)) {
+        return;
+    }
+    setMaxItems(context.program, target, maxItems);
+};
+// -- @minValue decorator ---------------------
+export const $minValue = (context, target, minValue) => {
+    validateDecoratorUniqueOnNode(context, target, $minValue);
+    validateDecoratorNotOnType(context, target, $minValueExclusive, $minValue);
+    const { program } = context;
+    if (!validateTargetingComparableType(context, target, "@minValue")) {
+        return;
+    }
+    if (!validateValueAssignableToTarget(context, target, minValue)) {
+        return;
+    }
+    if (!validateRange(context, minValue, getMaxValueAsNumeric(context.program, target) ??
+        getMaxValueExclusiveAsNumeric(context.program, target))) {
+        return;
+    }
+    setMinValue(program, target, minValue);
+};
+// -- @maxValue decorator ---------------------
+export const $maxValue = (context, target, maxValue) => {
+    validateDecoratorUniqueOnNode(context, target, $maxValue);
+    validateDecoratorNotOnType(context, target, $maxValueExclusive, $maxValue);
+    const { program } = context;
+    if (!validateTargetingComparableType(context, target, "@maxValue")) {
+        return;
+    }
+    if (!validateValueAssignableToTarget(context, target, maxValue)) {
+        return;
+    }
+    if (!validateRange(context, getMinValueAsNumeric(context.program, target) ??
+        getMinValueExclusiveAsNumeric(context.program, target), maxValue)) {
+        return;
+    }
+    setMaxValue(program, target, maxValue);
+};
+// -- @minValueExclusive decorator ---------------------
+export const $minValueExclusive = (context, target, minValueExclusive) => {
+    validateDecoratorUniqueOnNode(context, target, $minValueExclusive);
+    validateDecoratorNotOnType(context, target, $minValue, $minValueExclusive);
+    const { program } = context;
+    if (!validateTargetingComparableType(context, target, "@minValueExclusive")) {
+        return;
+    }
+    if (!validateValueAssignableToTarget(context, target, minValueExclusive)) {
+        return;
+    }
+    if (!validateRange(context, minValueExclusive, getMaxValueAsNumeric(context.program, target) ??
+        getMaxValueExclusiveAsNumeric(context.program, target))) {
+        return;
+    }
+    setMinValueExclusive(program, target, minValueExclusive);
+};
+// -- @maxValueExclusive decorator ---------------------
+export const $maxValueExclusive = (context, target, maxValueExclusive) => {
+    validateDecoratorUniqueOnNode(context, target, $maxValueExclusive);
+    validateDecoratorNotOnType(context, target, $maxValue, $maxValueExclusive);
+    const { program } = context;
+    if (!validateTargetingComparableType(context, target, "@maxValueExclusive")) {
+        return;
+    }
+    if (!validateValueAssignableToTarget(context, target, maxValueExclusive)) {
+        return;
+    }
+    if (!validateRange(context, getMinValueAsNumeric(context.program, target) ??
+        getMinValueExclusiveAsNumeric(context.program, target), maxValueExclusive)) {
+        return;
+    }
+    setMaxValueExclusive(program, target, maxValueExclusive);
+};
+// -- @secret decorator ---------------------
+const [isSecret, markSecret] = useStateSet(createStateSymbol("secretTypes"));
+/**
+ * Mark a value as a secret value that should be treated carefully to avoid exposure
+ * @param context Decorator context
+ * @param target Decorator target: a scalar, model property, model, union, or enum.
+ */
+export const $secret = (context, target) => {
+    validateDecoratorUniqueOnNode(context, target, $secret);
+    markSecret(context.program, target);
+};
+export { isSecret };
+const [getEncode, setEncodeData] = useStateMap(createStateSymbol("encode"));
+export const $encode = (context, target, encoding, encodeAs) => {
+    validateDecoratorUniqueOnNode(context, target, $encode);
+    const encodeData = computeEncoding(context.program, encoding, encodeAs);
+    if (encodeData === undefined) {
+        return;
+    }
+    const targetType = getPropertyType(target);
+    validateEncodeData(context, targetType, encodeData);
+    setEncodeData(context.program, target, encodeData);
+};
+function computeEncoding(program, encodingOrEncodeAs, encodeAs) {
+    const strType = program.checker.getStdType("string");
+    const resolvedEncodeAs = encodeAs ?? strType;
+    if (typeof encodingOrEncodeAs === "string") {
+        return { encoding: encodingOrEncodeAs, type: resolvedEncodeAs };
+    }
+    else if (isValue(encodingOrEncodeAs)) {
+        const member = encodingOrEncodeAs.value;
+        if (member.value && typeof member.value === "string") {
+            return { encoding: member.value, type: resolvedEncodeAs };
+        }
+        else {
+            return { encoding: getTypeName(member), type: resolvedEncodeAs };
+        }
+    }
+    else {
+        const originalType = encodingOrEncodeAs;
+        if (originalType !== strType) {
+            reportDiagnostic(program, {
+                code: "invalid-encode",
+                messageId: "firstArg",
+                target: encodingOrEncodeAs,
+            });
+            return undefined;
+        }
+        return { type: encodingOrEncodeAs };
+    }
+}
+function validateEncodeData(context, target, encodeData) {
+    function check(validTargets, validEncodeTypes) {
+        const checker = context.program.checker;
+        const isTargetValid = isTypeIn(target, (type) => validTargets.some((validTarget) => {
+            return ignoreDiagnostics(checker.isTypeAssignableTo(type, checker.getStdType(validTarget), target));
+        }));
+        if (!isTargetValid) {
+            reportDiagnostic(context.program, {
+                code: "invalid-encode",
+                messageId: "wrongType",
+                format: {
+                    encoding: encodeData.encoding ?? "string",
+                    type: getTypeName(target),
+                    expected: validTargets.join(", "),
+                },
+                target: context.decoratorTarget,
+            });
+        }
+        const isEncodingTypeValid = validEncodeTypes.some((validEncoding) => {
+            return ignoreDiagnostics(checker.isTypeAssignableTo(encodeData.type, checker.getStdType(validEncoding), target));
+        });
+        if (!isEncodingTypeValid) {
+            const typeName = getTypeName(encodeData.type);
+            reportDiagnostic(context.program, {
+                code: "invalid-encode",
+                messageId: ["unixTimestamp", "seconds", "milliseconds"].includes(encodeData.encoding ?? "string")
+                    ? "wrongNumericEncodingType"
+                    : "wrongEncodingType",
+                format: {
+                    encoding: encodeData.encoding,
+                    type: getTypeName(target),
+                    expected: validEncodeTypes.join(", "),
+                    actual: typeName,
+                },
+                target: context.decoratorTarget,
+            });
+        }
+    }
+    switch (encodeData.encoding) {
+        case "rfc3339":
+            return check(["utcDateTime", "offsetDateTime"], ["string"]);
+        case "rfc7231":
+            return check(["utcDateTime", "offsetDateTime"], ["string"]);
+        case "unixTimestamp":
+            return check(["utcDateTime"], ["integer"]);
+        case "seconds":
+            return check(["duration"], ["numeric"]);
+        case "milliseconds":
+            return check(["duration"], ["numeric"]);
+        case "base64":
+            return check(["bytes"], ["string"]);
+        case "base64url":
+            return check(["bytes"], ["string"]);
+        case undefined:
+            return check(["numeric", "boolean"], ["string"]);
+    }
+}
+export { getEncode };
+// -- @withOptionalProperties decorator ---------------------
+export const $withOptionalProperties = (context, target) => {
+    // Make all properties of the target type optional
+    target.properties.forEach((p) => (p.optional = true));
+};
+// -- @withoutOmittedProperties decorator ----------------------
+export const $withoutOmittedProperties = (context, target, omitProperties) => {
+    // Get the property or properties to omit
+    const omitNames = new Set();
+    if (omitProperties.kind === "String") {
+        omitNames.add(omitProperties.value);
+    }
+    else if (omitProperties.kind === "Union") {
+        for (const variant of omitProperties.variants.values()) {
+            if (variant.type.kind === "String") {
+                omitNames.add(variant.type.value);
+            }
+        }
+    }
+    // Remove all properties to be omitted
+    filterModelPropertiesInPlace(target, (prop) => !omitNames.has(prop.name));
+};
+// -- @withPickedProperties decorator ----------------------
+export const $withPickedProperties = (context, target, pickedProperties) => {
+    // Get the property or properties to pick
+    const pickedNames = new Set();
+    if (pickedProperties.kind === "String") {
+        pickedNames.add(pickedProperties.value);
+    }
+    else if (pickedProperties.kind === "Union") {
+        for (const variant of pickedProperties.variants.values()) {
+            if (variant.type.kind === "String") {
+                pickedNames.add(variant.type.value);
+            }
+        }
+    }
+    // Remove all properties not picked
+    filterModelPropertiesInPlace(target, (prop) => pickedNames.has(prop.name));
+};
+// -- @withoutDefaultValues decorator ----------------------
+export const $withoutDefaultValues = (context, target) => {
+    // remove all read-only properties from the target type
+    target.properties.forEach((p) => {
+        delete p.defaultValue;
+    });
+};
+// -- @tag decorator ---------------------
+const [getTagsState, setTags] = useStateMap(createStateSymbol("tagProperties"));
+// Set a tag on an operation, interface, or namespace.  There can be multiple tags on an
+// operation, interface, or namespace.
+export const $tag = (context, target, tag) => {
+    const tags = getTagsState(context.program, target);
+    if (tags) {
+        tags.push(tag);
+    }
+    else {
+        setTags(context.program, target, [tag]);
+    }
+};
+// Return the tags set on an operation or namespace
+export function getTags(program, target) {
+    return getTagsState(program, target) || [];
+}
+// Merge the tags for a operation with the tags that are on the namespace or
+// interface it resides within.
+export function getAllTags(program, target) {
+    const tags = new Set();
+    let current = target;
+    while (current !== undefined) {
+        for (const t of getTags(program, current)) {
+            tags.add(t);
+        }
+        // Move up to the parent
+        if (current.kind === "Operation") {
+            current = current.interface ?? current.namespace;
+        }
+        else {
+            // Type is a namespace or interface
+            current = current.namespace;
+        }
+    }
+    return tags.size > 0 ? Array.from(tags).reverse() : undefined;
+}
+// -- @friendlyName decorator ---------------------
+const [getFriendlyName, setFriendlyName] = useStateMap(createStateSymbol("friendlyNames"));
+export const $friendlyName = (context, target, friendlyName, sourceObject) => {
+    // workaround for current lack of functionality in compiler
+    // https://github.com/microsoft/typespec/issues/2717
+    if (target.kind === "Model" || target.kind === "Operation") {
+        if (context.decoratorTarget.kind === SyntaxKind.AugmentDecoratorStatement) {
+            if (ignoreDiagnostics(context.program.checker.resolveTypeReference(context.decoratorTarget.targetType))?.node !== target.node) {
+                return;
+            }
+        }
+        if (context.decoratorTarget.kind === SyntaxKind.DecoratorExpression) {
+            if (context.decoratorTarget.parent !== target.node) {
+                return;
+            }
+        }
+    }
+    // If an object was passed in, use it to format the friendly name
+    if (sourceObject) {
+        friendlyName = replaceTemplatedStringFromProperties(friendlyName, sourceObject);
+    }
+    setFriendlyName(context.program, target, friendlyName);
+};
+export { getFriendlyName };
+/**
+ * `@key` - mark a model property as the key to identify instances of that type
+ *
+ * The optional first argument accepts an alternate key name which may be used by emitters.
+ * Otherwise, the name of the target property will be used.
+ *
+ * `@key` can only be applied to model properties.
+ */
+export const $key = (context, entity, altName) => {
+    // Ensure that the key property is not marked as optional
+    if (entity.optional) {
+        reportDiagnostic(context.program, {
+            code: "no-optional-key",
+            format: { propertyName: entity.name },
+            target: entity,
+        });
+        return;
+    }
+    // Register the key property
+    setKey(context.program, entity, altName || entity.name);
+};
+export { getKeyName, isKey } from "./key.js";
+/**
+ * Return the deprecated message or undefined if not deprecated
+ * @param program Program
+ * @param type Type
+ */
+export function getDeprecated(program, type) {
+    return getDeprecationDetails(program, type)?.message;
+}
+const [getOverloads, setOverloads] = useStateMap(createStateSymbol("overloadedByKey"));
+const [getOverloadedOperation, setOverloadBase] = useStateMap(createStateSymbol("overloadsOperation"));
+/**
+ * `@overload` - Indicate that the target overloads (specializes) the overloads type.
+ * @param context DecoratorContext
+ * @param target The specializing operation declaration
+ * @param overloadBase The operation to be overloaded.
+ */
+export const $overload = (context, target, overloadBase) => {
+    // Ensure that the overloaded method arguments are a subtype of the original operation.
+    const [paramValid, paramDiagnostics] = context.program.checker.isTypeAssignableTo(target.parameters, overloadBase.parameters, target);
+    if (!paramValid)
+        context.program.reportDiagnostics(paramDiagnostics);
+    const [returnTypeValid, returnTypeDiagnostics] = context.program.checker.isTypeAssignableTo(target.returnType, overloadBase.returnType, target);
+    if (!returnTypeValid)
+        context.program.reportDiagnostics(returnTypeDiagnostics);
+    if (!areOperationsInSameContainer(target, overloadBase)) {
+        reportDiagnostic(context.program, {
+            code: "overload-same-parent",
+            target: context.decoratorTarget,
+        });
+    }
+    // Save the information about the overloaded operation
+    setOverloadBase(context.program, target, overloadBase);
+    const existingOverloads = getOverloads(context.program, overloadBase) || new Array();
+    setOverloads(context.program, overloadBase, existingOverloads.concat(target));
+};
+function areOperationsInSameContainer(op1, op2) {
+    if (op1.interface || op2.interface) {
+        return (op1.interface === op2.interface ||
+            // Handle mutated/cloned types (e.g., in versioned namespaces) where operations
+            // may reference different clones of the same interface by comparing AST nodes.
+            (op1.interface?.node !== undefined && op1.interface?.node === op2.interface?.node));
+    }
+    return (op1.namespace === op2.namespace ||
+        (op1.namespace?.node !== undefined && op1.namespace?.node === op2.namespace?.node));
+}
+export { 
+/**
+ * If the given operation overloads another operation, return that operation.
+ * @param program Program
+ * @param operation The operation to check for an overload target.
+ * @returns The operation this operation overloads, if any.
+ */
+getOverloadedOperation, 
+/**
+ * Get all operations that are marked as overloads of the given operation
+ * @param program Program
+ * @param operation Operation
+ * @returns An array of operations that overload the given operation.
+ */
+getOverloads, };
+function validateRange(context, min, max) {
+    if (min === undefined || max === undefined) {
+        return true;
+    }
+    if (!isNumeric(min) || !isNumeric(max)) {
+        return true;
+    }
+    if (min.gt(max)) {
+        reportDiagnostic(context.program, {
+            code: "invalid-range",
+            format: { start: min.toString(), end: max.toString() },
+            target: context.decoratorTarget,
+        });
+        return false;
+    }
+    return true;
+}
+export const discriminatedDecorator = (context, entity, options = {}) => {
+    setDiscriminatedOptions(context.program, entity, {
+        envelope: "object",
+        discriminatorPropertyName: "kind",
+        envelopePropertyName: "value",
+        ...options,
+    });
+    const [_, diagnostics] = getDiscriminatedUnion(context.program, entity);
+    context.program.reportDiagnostics(diagnostics);
+};
+export const $discriminator = (context, entity, propertyName) => {
+    setDiscriminator(context.program, entity, { propertyName });
+};
+const [getExamplesState, setExamples] = useStateMap(createStateSymbol("examples"));
+export const $example = (context, target, _example, options) => {
+    const decorator = target.decorators.find((d) => d.decorator === $example && d.node === context.decoratorTarget);
+    compilerAssert(decorator, `Couldn't find @example decorator`, context.decoratorTarget);
+    const rawExample = decorator.args[0].value;
+    // skip validation in cloned types
+    if (Realm.realmForType.get(target) === undefined) {
+        if (!checkExampleValid(context.program, rawExample, target.kind === "ModelProperty" ? target.type : target, context.getArgumentTarget(0))) {
+            return;
+        }
+    }
+    let list = getExamplesState(context.program, target);
+    if (list === undefined) {
+        list = [];
+        setExamples(context.program, target, list);
+    }
+    list.push({ value: rawExample, ...options });
+};
+export function getExamples(program, target) {
+    return getExamplesState(program, target) ?? [];
+}
+const [getOpExamplesState, setOpExamples] = useStateMap(createStateSymbol("opExamples"));
+export const $opExample = (context, target, _example, options) => {
+    const decorator = target.decorators.find((d) => d.decorator === $opExample && d.node === context.decoratorTarget);
+    compilerAssert(decorator, `Couldn't find @opExample decorator`, context.decoratorTarget);
+    const rawExampleConfig = decorator.args[0].value;
+    const parameters = rawExampleConfig.properties.get("parameters")?.value;
+    const returnType = rawExampleConfig.properties.get("returnType")?.value;
+    // skip validation in cloned types
+    if (Realm.realmForType.get(target) === undefined) {
+        if (parameters &&
+            !checkExampleValid(context.program, parameters, target.parameters, context.getArgumentTarget(0))) {
+            return;
+        }
+        if (returnType &&
+            !checkExampleValid(context.program, returnType, target.returnType, context.getArgumentTarget(0))) {
+            return;
+        }
+    }
+    let list = getOpExamplesState(context.program, target);
+    if (list === undefined) {
+        list = [];
+        setOpExamples(context.program, target, list);
+    }
+    list.push({ parameters, returnType, ...options });
+};
+function checkExampleValid(program, value, target, diagnosticTarget) {
+    const exactType = program.checker.getValueExactType(value);
+    const [assignable, diagnostics] = program.checker.isTypeAssignableTo(exactType ?? value.type, target, diagnosticTarget);
+    if (!assignable) {
+        program.reportDiagnostics(diagnostics);
+    }
+    return assignable;
+}
+export function getOpExamples(program, target) {
+    return getOpExamplesState(program, target) ?? [];
+}
+//# sourceMappingURL=decorators.js.map