@typespec/compiler 0.41.0

package/dist/lib/decorators.js

@@ -0,0 +1,745 @@
+import { validateDecoratorNotOnType, validateDecoratorTarget, validateDecoratorTargetIntrinsic, } from "../core/decorator-utils.js";
+import { getDiscriminatedUnion, getTypeName, validateDecoratorUniqueOnNode, } from "../core/index.js";
+import { createDiagnostic, reportDiagnostic } from "../core/messages.js";
+export * from "./service.js";
+export const namespace = "TypeSpec";
+function replaceTemplatedStringFromProperties(formatString, sourceObject) {
+    // Template parameters are not valid source objects, just skip them
+    if (sourceObject.kind === "TemplateParameter") {
+        return formatString;
+    }
+    return formatString.replace(/{(\w+)}/g, (_, propName) => {
+        return sourceObject[propName];
+    });
+}
+function setTemplatedStringProperty(key, program, target, text, sourceObject) {
+    // If an object was passed in, use it to format the documentation string
+    if (sourceObject) {
+        text = replaceTemplatedStringFromProperties(text, sourceObject);
+    }
+    program.stateMap(key).set(target, text);
+}
+function createStateSymbol(name) {
+    return Symbol.for(`TypeSpec.${name}`);
+}
+const summaryKey = 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 function $summary(context, target, text, sourceObject) {
+    setTemplatedStringProperty(summaryKey, context.program, target, text, sourceObject);
+}
+export function getSummary(program, type) {
+    return program.stateMap(summaryKey).get(type);
+}
+const docsKey = createStateSymbol("docs");
+/**
+ * @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 function $doc(context, target, text, sourceObject) {
+    validateDecoratorUniqueOnNode(context, target, $doc);
+    setTemplatedStringProperty(docsKey, context.program, target, text, sourceObject);
+}
+export function getDoc(program, target) {
+    return program.stateMap(docsKey).get(target);
+}
+export function $inspectType(program, 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 function $inspectTypeName(program, target, text) {
+    // eslint-disable-next-line no-console
+    if (text)
+        console.log(text);
+    // eslint-disable-next-line no-console
+    console.log(getTypeName(target));
+}
+const indexTypeKey = createStateSymbol("index");
+export function $indexer(context, target, key, value) {
+    const indexer = { key, value };
+    context.program.stateMap(indexTypeKey).set(target, indexer);
+}
+export function getIndexer(program, target) {
+    return program.stateMap(indexTypeKey).get(target);
+}
+export function isStringType(program, target) {
+    const coreType = program.checker.getStdType("string");
+    const stringType = target.projector ? target.projector.projectType(coreType) : coreType;
+    return (target.kind === "Scalar" && program.checker.isTypeAssignableTo(target, stringType, target)[0]);
+}
+export function isNumericType(program, target) {
+    const coreType = program.checker.getStdType("numeric");
+    const numericType = target.projector ? target.projector.projectType(coreType) : coreType;
+    return (target.kind === "Scalar" && program.checker.isTypeAssignableTo(target, numericType, target)[0]);
+}
+/**
+ * Check if a model is an array type.
+ * @param type Model type
+ */
+export function isArrayModelType(program, type) {
+    return Boolean(type.indexer && type.indexer.key.name === "integer");
+}
+/**
+ * Check if a model is an array type.
+ * @param type Model type
+ */
+export function isRecordModelType(program, type) {
+    return Boolean(type.indexer && type.indexer.key.name === "string");
+}
+/**
+ * Return the type of the property or the model itself.
+ */
+export function getPropertyType(target) {
+    if (target.kind === "ModelProperty") {
+        return target.type;
+    }
+    else {
+        return target;
+    }
+}
+// -- @error decorator ----------------------
+const errorKey = createStateSymbol("error");
+/**
+ * `@error` decorator marks a model as an error type.
+ *
+ * `@error` can only be specified on a model.
+ */
+export function $error(context, entity) {
+    validateDecoratorUniqueOnNode(context, entity, $error);
+    context.program.stateSet(errorKey).add(entity);
+}
+export function isErrorModel(program, target) {
+    return program.stateSet(errorKey).has(target);
+}
+// -- @format decorator ---------------------
+const formatValuesKey = createStateSymbol("formatValues");
+/**
+ * `@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 function $format(context, target, format) {
+    validateDecoratorUniqueOnNode(context, target, $format);
+    if (!validateDecoratorTargetIntrinsic(context, target, "@format", ["string", "bytes"])) {
+        return;
+    }
+    context.program.stateMap(formatValuesKey).set(target, format);
+}
+export function getFormat(program, target) {
+    return program.stateMap(formatValuesKey).get(target);
+}
+// -- @pattern decorator ---------------------
+const patternValuesKey = createStateSymbol("patternValues");
+export function $pattern(context, target, pattern) {
+    validateDecoratorUniqueOnNode(context, target, $pattern);
+    if (!validateDecoratorTargetIntrinsic(context, target, "@pattern", "string")) {
+        return;
+    }
+    context.program.stateMap(patternValuesKey).set(target, pattern);
+}
+export function getPattern(program, target) {
+    return program.stateMap(patternValuesKey).get(target);
+}
+// -- @minLength decorator ---------------------
+const minLengthValuesKey = createStateSymbol("minLengthValues");
+export function $minLength(context, target, minLength) {
+    validateDecoratorUniqueOnNode(context, target, $minLength);
+    if (!validateDecoratorTargetIntrinsic(context, target, "@minLength", "string") ||
+        !validateRange(context, minLength, getMaxLength(context.program, target))) {
+        return;
+    }
+    context.program.stateMap(minLengthValuesKey).set(target, minLength);
+}
+export function getMinLength(program, target) {
+    return program.stateMap(minLengthValuesKey).get(target);
+}
+// -- @maxLength decorator ---------------------
+const maxLengthValuesKey = createStateSymbol("maxLengthValues");
+export function $maxLength(context, target, maxLength) {
+    validateDecoratorUniqueOnNode(context, target, $maxLength);
+    if (!validateDecoratorTargetIntrinsic(context, target, "@maxLength", "string") ||
+        !validateRange(context, getMinLength(context.program, target), maxLength)) {
+        return;
+    }
+    context.program.stateMap(maxLengthValuesKey).set(target, maxLength);
+}
+export function getMaxLength(program, target) {
+    return program.stateMap(maxLengthValuesKey).get(target);
+}
+// -- @minItems decorator ---------------------
+const minItemsValuesKey = createStateSymbol("minItems");
+export function $minItems(context, target, minItems) {
+    validateDecoratorUniqueOnNode(context, target, $minItems);
+    if (!isArrayModelType(context.program, target.kind === "Model" ? target : target.type)) {
+        reportDiagnostic(context.program, {
+            code: "decorator-wrong-target",
+            format: {
+                decorator: "@minItems",
+                to: `non Array type`,
+            },
+            target: context.decoratorTarget,
+        });
+    }
+    if (!validateRange(context, minItems, getMaxItems(context.program, target))) {
+        return;
+    }
+    context.program.stateMap(minItemsValuesKey).set(target, minItems);
+}
+export function getMinItems(program, target) {
+    return program.stateMap(minItemsValuesKey).get(target);
+}
+// -- @maxLength decorator ---------------------
+const maxItemsValuesKey = createStateSymbol("maxItems");
+export function $maxItems(context, target, maxItems) {
+    validateDecoratorUniqueOnNode(context, target, $maxItems);
+    if (!isArrayModelType(context.program, target.kind === "Model" ? target : target.type)) {
+        reportDiagnostic(context.program, {
+            code: "decorator-wrong-target",
+            format: {
+                decorator: "@maxItems",
+                to: `non Array type`,
+            },
+            target: context.decoratorTarget,
+        });
+    }
+    if (!validateRange(context, getMinItems(context.program, target), maxItems)) {
+        return;
+    }
+    context.program.stateMap(maxItemsValuesKey).set(target, maxItems);
+}
+export function getMaxItems(program, target) {
+    return program.stateMap(maxItemsValuesKey).get(target);
+}
+// -- @minValue decorator ---------------------
+const minValuesKey = createStateSymbol("minValues");
+export function $minValue(context, target, minValue) {
+    var _a;
+    validateDecoratorUniqueOnNode(context, target, $minValue);
+    validateDecoratorNotOnType(context, target, $minValueExclusive, $minValue);
+    const { program } = context;
+    if (!isNumericType(program, getPropertyType(target))) {
+        program.reportDiagnostic(createDiagnostic({
+            code: "decorator-wrong-target",
+            format: { decorator: "@minValue", to: "non-numeric type" },
+            target,
+        }));
+        return;
+    }
+    if (!validateRange(context, minValue, (_a = getMaxValue(context.program, target)) !== null && _a !== void 0 ? _a : getMaxValueExclusive(context.program, target))) {
+        return;
+    }
+    program.stateMap(minValuesKey).set(target, minValue);
+}
+export function getMinValue(program, target) {
+    return program.stateMap(minValuesKey).get(target);
+}
+// -- @maxValue decorator ---------------------
+const maxValuesKey = createStateSymbol("maxValues");
+export function $maxValue(context, target, maxValue) {
+    var _a;
+    validateDecoratorUniqueOnNode(context, target, $maxValue);
+    validateDecoratorNotOnType(context, target, $maxValueExclusive, $maxValue);
+    const { program } = context;
+    if (!isNumericType(program, getPropertyType(target))) {
+        program.reportDiagnostic(createDiagnostic({
+            code: "decorator-wrong-target",
+            format: { decorator: "@maxValue", to: "non-numeric type" },
+            target,
+        }));
+        return;
+    }
+    if (!validateRange(context, (_a = getMinValue(context.program, target)) !== null && _a !== void 0 ? _a : getMinValueExclusive(context.program, target), maxValue)) {
+        return;
+    }
+    program.stateMap(maxValuesKey).set(target, maxValue);
+}
+export function getMaxValue(program, target) {
+    return program.stateMap(maxValuesKey).get(target);
+}
+// -- @minValueExclusive decorator ---------------------
+const minValueExclusiveKey = createStateSymbol("minValueExclusive");
+export function $minValueExclusive(context, target, minValueExclusive) {
+    var _a;
+    validateDecoratorUniqueOnNode(context, target, $minValueExclusive);
+    validateDecoratorNotOnType(context, target, $minValue, $minValueExclusive);
+    const { program } = context;
+    if (!isNumericType(program, getPropertyType(target))) {
+        program.reportDiagnostic(createDiagnostic({
+            code: "decorator-wrong-target",
+            format: { decorator: "@minValueExclusive", to: "non-numeric type" },
+            target,
+        }));
+        return;
+    }
+    if (!validateRange(context, minValueExclusive, (_a = getMaxValue(context.program, target)) !== null && _a !== void 0 ? _a : getMaxValueExclusive(context.program, target))) {
+        return;
+    }
+    program.stateMap(minValueExclusiveKey).set(target, minValueExclusive);
+}
+export function getMinValueExclusive(program, target) {
+    return program.stateMap(minValueExclusiveKey).get(target);
+}
+// -- @maxValueExclusive decorator ---------------------
+const maxValueExclusiveKey = createStateSymbol("maxValueExclusive");
+export function $maxValueExclusive(context, target, maxValueExclusive) {
+    var _a;
+    validateDecoratorUniqueOnNode(context, target, $maxValueExclusive);
+    validateDecoratorNotOnType(context, target, $maxValue, $maxValueExclusive);
+    const { program } = context;
+    if (!isNumericType(program, getPropertyType(target))) {
+        program.reportDiagnostic(createDiagnostic({
+            code: "decorator-wrong-target",
+            format: { decorator: "@maxValue", to: "non-numeric type" },
+            target,
+        }));
+        return;
+    }
+    if (!validateRange(context, (_a = getMinValue(context.program, target)) !== null && _a !== void 0 ? _a : getMinValueExclusive(context.program, target), maxValueExclusive)) {
+        return;
+    }
+    program.stateMap(maxValueExclusiveKey).set(target, maxValueExclusive);
+}
+export function getMaxValueExclusive(program, target) {
+    return program.stateMap(maxValueExclusiveKey).get(target);
+}
+// -- @secret decorator ---------------------
+const secretTypesKey = createStateSymbol("secretTypes");
+/**
+ * Mark a string as a secret value that should be treated carefully to avoid exposure
+ * @param context Decorator context
+ * @param target Decorator target, either a string model or a property with type string.
+ */
+export function $secret(context, target) {
+    validateDecoratorUniqueOnNode(context, target, $secret);
+    if (!validateDecoratorTargetIntrinsic(context, target, "@secret", "string")) {
+        return;
+    }
+    context.program.stateMap(secretTypesKey).set(target, true);
+}
+export function isSecret(program, target) {
+    return program.stateMap(secretTypesKey).get(target);
+}
+// -- @visibility decorator ---------------------
+const visibilitySettingsKey = createStateSymbol("visibilitySettings");
+export function $visibility(context, target, ...visibilities) {
+    validateDecoratorUniqueOnNode(context, target, $visibility);
+    context.program.stateMap(visibilitySettingsKey).set(target, visibilities);
+}
+export function getVisibility(program, target) {
+    return program.stateMap(visibilitySettingsKey).get(target);
+}
+export function $withVisibility(context, target, ...visibilities) {
+    filterModelPropertiesInPlace(target, (p) => isVisible(context.program, p, visibilities));
+}
+export function isVisible(program, property, visibilities) {
+    const propertyVisibilities = getVisibility(program, property);
+    return !propertyVisibilities || propertyVisibilities.some((v) => visibilities.includes(v));
+}
+function filterModelPropertiesInPlace(model, filter) {
+    for (const [key, prop] of model.properties) {
+        if (!filter(prop)) {
+            model.properties.delete(key);
+        }
+    }
+}
+// -- @withOptionalProperties decorator ---------------------
+export function $withOptionalProperties(context, target) {
+    // Make all properties of the target type optional
+    target.properties.forEach((p) => (p.optional = true));
+}
+// -- @withUpdateableProperties decorator ----------------------
+export function $withUpdateableProperties(context, target) {
+    if (!validateDecoratorTarget(context, target, "@withUpdateableProperties", "Model")) {
+        return;
+    }
+    filterModelPropertiesInPlace(target, (p) => isVisible(context.program, p, ["update"]));
+}
+// -- @withoutOmittedProperties decorator ----------------------
+export function $withoutOmittedProperties(context, target, omitProperties) {
+    // Get the property or properties to omit
+    const omitNames = new Set();
+    if (typeof omitProperties === "string") {
+        omitNames.add(omitProperties);
+    }
+    else {
+        for (const value of omitProperties.options) {
+            if (value.kind === "String") {
+                omitNames.add(value.value);
+            }
+        }
+    }
+    // Remove all properties to be omitted
+    filterModelPropertiesInPlace(target, (prop) => !omitNames.has(prop.name));
+}
+// -- @withoutDefaultValues decorator ----------------------
+export function $withoutDefaultValues(context, target) {
+    // remove all read-only properties from the target type
+    target.properties.forEach((p) => delete p.default);
+}
+// -- @list decorator ---------------------
+const listPropertiesKey = createStateSymbol("listProperties");
+export function $list(context, target, listedType) {
+    if (listedType && listedType.kind === "TemplateParameter") {
+        // Silently return because this is probably being used in a templated interface
+        return;
+    }
+    if (listedType && listedType.kind !== "Model") {
+        reportDiagnostic(context.program, {
+            code: "list-type-not-model",
+            target: context.getArgumentTarget(0),
+        });
+        return;
+    }
+    context.program.stateMap(listPropertiesKey).set(target, listedType);
+}
+export function getListOperationType(program, target) {
+    return program.stateMap(listPropertiesKey).get(target);
+}
+export function isListOperation(program, target) {
+    // The type stored for the operation
+    return program.stateMap(listPropertiesKey).has(target);
+}
+// -- @tag decorator ---------------------
+const tagPropertiesKey = createStateSymbol("tagProperties");
+// Set a tag on an operation, interface, or namespace.  There can be multiple tags on an
+// operation, interface, or namespace.
+export function $tag(context, target, tag) {
+    const tags = context.program.stateMap(tagPropertiesKey).get(target);
+    if (tags) {
+        tags.push(tag);
+    }
+    else {
+        context.program.stateMap(tagPropertiesKey).set(target, [tag]);
+    }
+}
+// Return the tags set on an operation or namespace
+export function getTags(program, target) {
+    return program.stateMap(tagPropertiesKey).get(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) {
+    var _a;
+    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 = (_a = current.interface) !== null && _a !== void 0 ? _a : current.namespace;
+        }
+        else {
+            // Type is a namespace or interface
+            current = current.namespace;
+        }
+    }
+    return tags.size > 0 ? Array.from(tags).reverse() : undefined;
+}
+// -- @friendlyName decorator ---------------------
+const friendlyNamesKey = createStateSymbol("friendlyNames");
+export function $friendlyName(context, target, friendlyName, sourceObject) {
+    // If an object was passed in, use it to format the friendly name
+    if (sourceObject) {
+        friendlyName = replaceTemplatedStringFromProperties(friendlyName, sourceObject);
+    }
+    context.program.stateMap(friendlyNamesKey).set(target, friendlyName);
+}
+export function getFriendlyName(program, target) {
+    return program.stateMap(friendlyNamesKey).get(target);
+}
+const knownValuesKey = createStateSymbol("knownValues");
+/**
+ * `@knownValues` marks a string type with an enum that contains all known values
+ *
+ * The first parameter is a reference to an enum type that describes all possible values that the
+ * type accepts.
+ *
+ * `@knownValues` can only be applied to model types that extend `string`.
+ *
+ * @param target Decorator target. Must be a string. (model Foo extends string)
+ * @param knownValues Must be an enum.
+ */
+export function $knownValues(context, target, knownValues) {
+    if (!validateDecoratorTargetIntrinsic(context, target, "@knownValues", [
+        "string",
+        "int8",
+        "int16",
+        "int32",
+        "int64",
+        "float32",
+        "float64",
+    ])) {
+        return;
+    }
+    for (const member of knownValues.members.values()) {
+        const propertyType = getPropertyType(target);
+        if (!isEnumMemberAssignableToType(context.program, propertyType, member)) {
+            reportDiagnostic(context.program, {
+                code: "known-values-invalid-enum",
+                format: {
+                    member: member.name,
+                    type: context.program.checker.getTypeName(propertyType),
+                },
+                target,
+            });
+            return;
+        }
+    }
+    context.program.stateMap(knownValuesKey).set(target, knownValues);
+}
+function isEnumMemberAssignableToType(program, typeName, member) {
+    const memberType = member.value !== undefined ? typeof member.value : "string";
+    switch (memberType) {
+        case "string":
+            return isStringType(program, typeName);
+        case "number":
+            return isNumericType(program, typeName);
+        default:
+            return false;
+    }
+}
+export function getKnownValues(program, target) {
+    return program.stateMap(knownValuesKey).get(target);
+}
+const keyKey = createStateSymbol("key");
+/**
+ * `@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 function $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
+    context.program.stateMap(keyKey).set(entity, altName || entity.name);
+}
+export function isKey(program, property) {
+    return program.stateMap(keyKey).has(property);
+}
+export function getKeyName(program, property) {
+    return program.stateMap(keyKey).get(property);
+}
+/**
+ * `@withDefaultKeyVisibility` - set the visibility of key properties in a model if not already set
+ *
+ * The first argument accepts a string representing the desired default
+ * visibility value.  If a key property already has a `visibility` decorator
+ * then the default visibility is not applied.
+ *
+ * `@withDefaultKeyVisibility` can only be applied to model types.
+ */
+export function $withDefaultKeyVisibility(context, entity, visibility) {
+    const keyProperties = [];
+    entity.properties.forEach((prop) => {
+        // Keep track of any key property without a visibility
+        if (isKey(context.program, prop) && !getVisibility(context.program, prop)) {
+            keyProperties.push(prop);
+        }
+    });
+    // For each key property without a visibility, clone it and add the specified
+    // default visibility value
+    keyProperties.forEach((keyProp) => {
+        entity.properties.set(keyProp.name, context.program.checker.cloneType(keyProp, {
+            decorators: [
+                ...keyProp.decorators,
+                {
+                    decorator: $visibility,
+                    args: [{ value: context.program.checker.createLiteralType(visibility) }],
+                },
+            ],
+        }));
+    });
+}
+/**
+ * Mark a type as deprecated
+ * @param context DecoratorContext
+ * @param target Decorator target
+ * @param message Deprecation target.
+ *
+ * @example
+ * ``` @deprecated("Foo is deprecated, use Bar instead.")
+ *     model Foo {}
+ * ```
+ */
+export function $deprecated(context, target, message) {
+    return context.program.stateMap(deprecatedKey).set(target, message);
+}
+const deprecatedKey = createStateSymbol("deprecated");
+/**
+ * Check if the given type is deprecated
+ * @param program Program
+ * @param type Type
+ */
+export function isDeprecated(program, type) {
+    return program.stateMap(deprecatedKey).has(type);
+}
+/**
+ * Return the deprecated message or undefined if not deprecated
+ * @param program Program
+ * @param type Type
+ */
+export function getDeprecated(program, type) {
+    return program.stateMap(deprecatedKey).get(type);
+}
+const overloadedByKey = createStateSymbol("overloadedByKey");
+const overloadsOperationKey = 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 function $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
+    context.program.stateMap(overloadsOperationKey).set(target, overloadBase);
+    const existingOverloads = getOverloads(context.program, overloadBase) || new Array();
+    context.program.stateMap(overloadedByKey).set(overloadBase, existingOverloads.concat(target));
+}
+function areOperationsInSameContainer(op1, op2) {
+    return op1.interface || op2.interface
+        ? op1.interface === op2.interface
+        : op1.namespace === op2.namespace;
+}
+/**
+ * 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.
+ */
+export function getOverloads(program, operation) {
+    return program.stateMap(overloadedByKey).get(operation);
+}
+/**
+ * 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.
+ */
+export function getOverloadedOperation(program, operation) {
+    return program.stateMap(overloadsOperationKey).get(operation);
+}
+const projectedNameKey = createStateSymbol("projectedNameKey");
+/**
+ * `@projectedName` - Indicate that this entity should be renamed according to the given projection.
+ * @param context DecoratorContext
+ * @param target The that should have a different name.
+ * @param projectionName Name of the projection (e.g. "toJson", "toCSharp")
+ * @param projectedName Name of the type should have in the scope of the projection specified.
+ */
+export function $projectedName(context, target, projectionName, projectedName) {
+    let map = context.program.stateMap(projectedNameKey).get(target);
+    if (map === undefined) {
+        map = new Map();
+        context.program.stateMap(projectedNameKey).set(target, map);
+    }
+    map.set(projectionName, projectedName);
+}
+/**
+ * @param program Program
+ * @param target Target
+ * @returns Map of the projected names for the given entity.
+ */
+export function getProjectedNames(program, target) {
+    return program.stateMap(projectedNameKey).get(target);
+}
+/**
+ * Get the projected name of the given entity for the given projection.
+ * @param program Program
+ * @param target Target
+ * @returns Projected name for the given projection
+ */
+export function getProjectedName(program, target, projectionName) {
+    var _a;
+    return (_a = getProjectedNames(program, target)) === null || _a === void 0 ? void 0 : _a.get(projectionName);
+}
+/**
+ * Get the projected name of the given entity for the given projection.
+ * @param program Program
+ * @param target Target
+ * @returns Projected name for the given projection
+ */
+export function hasProjectedName(program, target, projectionName) {
+    var _a, _b;
+    return (_b = (_a = getProjectedNames(program, target)) === null || _a === void 0 ? void 0 : _a.has(projectionName)) !== null && _b !== void 0 ? _b : false;
+}
+function validateRange(context, min, max) {
+    if (min === undefined || max === undefined) {
+        return true;
+    }
+    if (min > max) {
+        reportDiagnostic(context.program, {
+            code: "invalid-range",
+            format: { start: min.toString(), end: max.toString() },
+            target: context.decoratorTarget,
+        });
+        return false;
+    }
+    return true;
+}
+const discriminatorKey = createStateSymbol("discriminator");
+export function $discriminator(context, entity, propertyName) {
+    const discriminator = { propertyName };
+    if (entity.kind === "Union") {
+        // we can validate discriminator up front for unions. Models are validated in the accessor as we might not have the reference to all derived types at this time.
+        const [, diagnostics] = getDiscriminatedUnion(entity, discriminator);
+        if (diagnostics.length > 0) {
+            context.program.reportDiagnostics(diagnostics);
+            return;
+        }
+    }
+    context.program.stateMap(discriminatorKey).set(entity, discriminator);
+}
+export function getDiscriminator(program, entity) {
+    return program.stateMap(discriminatorKey).get(entity);
+}
+export function getDiscriminatedTypes(program) {
+    return [...program.stateMap(discriminatorKey).entries()];
+}
+//# sourceMappingURL=decorators.js.map