@azure-tools/typespec-ts 0.55.0-dev.1 → 0.55.0-dev.3

package/dist/src/modular/emitModels.js

@@ -1,850 +0,0 @@
-import { isPagedResultModel, isReadOnly, listAllServiceNamespaces, UsageFlags, } from "@azure-tools/typespec-client-generator-core";
-import { StructureKind, } from "ts-morph";
-import { fixLeadingNumber, NameType, normalizeName } from "../rlc-common/index.js";
-// import { isKey } from "@typespec/compiler";
-import { getExternalModel, getModelExpression, getMultipartFileTypeExpression, } from "./type-expressions/get-model-expression.js";
-import { getNamespaceFullName, NoTarget } from "@typespec/compiler";
-import { isMetadata, isOrExtendsHttpFile, Visibility } from "@typespec/http";
-import path from "path";
-import { useContext } from "../contextManager.js";
-import { addDeclaration } from "../framework/declaration.js";
-import { emitQueue, flattenPropertyModelMap, getAllOperationsFromClient, pagedModelsUsedInNonPagingOps, } from "../framework/hooks/sdkTypes.js";
-import { refkey } from "../framework/refkey.js";
-import { reportDiagnostic } from "../lib.js";
-import { getClientHierarchyMap } from "../utils/clientUtils.js";
-import { isAzureCoreErrorType } from "../utils/modelUtils.js";
-import { getMethodHierarchiesMap } from "../utils/operationUtil.js";
-import { getHeaderClientOptions } from "./helpers/clientOptionHelpers.js";
-import { buildNonModelResponseTypeDeclaration, checkWrapNonModelReturn, getAllAncestors, getAllProperties, } from "./helpers/operationHelpers.js";
-import { getDirectSubtypes } from "./helpers/typeHelpers.js";
-import { buildModelDeserializer, buildPropertyDeserializer, } from "./serialization/buildDeserializerFunction.js";
-import { buildModelSerializer, buildPropertySerializer, } from "./serialization/buildSerializerFunction.js";
-import { buildXmlModelDeserializer, buildXmlModelSerializer, buildXmlObjectModelDeserializer, buildXmlObjectModelSerializer, hasXmlSerialization, } from "./serialization/buildXmlSerializerFunction.js";
-import { getAllDiscriminatedValues, getPropertyWithOverrides, isDiscriminatedUnion, } from "./serialization/serializeUtils.js";
-import { isExtensibleEnum } from "./type-expressions/get-enum-expression.js";
-import { getTypeExpression, normalizeModelPropertyName, } from "./type-expressions/get-type-expression.js";
-function isGenerableType(type) {
-    return (type.kind === "model" ||
-        type.kind === "enum" ||
-        type.kind === "union" ||
-        type.kind === "dict" ||
-        type.kind === "array" ||
-        (type.kind === "nullable" &&
-            isGenerableType(type.type) &&
-            Boolean(type.name) &&
-            !type.isGeneratedName));
-}
-export function emitTypes(context, { sourceRoot }) {
-    const outputProject = useContext("outputProject");
-    let sourceFile;
-    for (const type of emitQueue) {
-        if (!isGenerableType(type)) {
-            continue;
-        }
-        const namespaces = getModelNamespaces(context, type);
-        const filepath = getModelsPath(sourceRoot, namespaces);
-        sourceFile = outputProject.getSourceFile(filepath);
-        if (!sourceFile) {
-            sourceFile = outputProject.createSourceFile(filepath);
-            sourceFile.addStatements(`/**
-* This file contains only generated model types and their (de)serializers.
-* Disable the following rules for internal models with '_' prefix and deserializers which require 'any' for raw JSON input.
-*/
-/* eslint-disable @typescript-eslint/naming-convention */
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */`);
-        }
-        emitType(context, type, sourceFile);
-    }
-    // Emit serialization/deserialization functions for flattened properties
-    for (const [property, _] of flattenPropertyModelMap) {
-        const namespaces = getModelNamespaces(context, property.type);
-        const filepath = getModelsPath(sourceRoot, namespaces);
-        sourceFile = outputProject.getSourceFile(filepath);
-        addSerializationFunctions(context, property, sourceFile);
-    }
-    const modelFiles = outputProject.getSourceFiles(sourceRoot + "/models/**/*.ts");
-    const result = [];
-    for (const modelFile of modelFiles) {
-        if (modelFile.getInterfaces().length === 0 &&
-            modelFile.getTypeAliases().length === 0 &&
-            modelFile.getEnums().length === 0) {
-            outputProject.removeSourceFile(modelFile);
-            continue;
-        }
-        result.push(modelFile);
-    }
-    return result;
-}
-/**
- * Emits the XxxResponse wrapper type aliases for non-model return operations
- * into the models.ts file, so they are exported publicly as part of the models API surface.
- * This must be called after emitTypes() and before buildSubpathIndexFile("models").
- */
-export function emitNonModelResponseTypes(context, { sourceRoot }) {
-    const outputProject = useContext("outputProject");
-    const clientMap = getClientHierarchyMap(context);
-    const filepath = getModelsPath(sourceRoot);
-    let modelsFile = outputProject.getSourceFile(filepath);
-    for (const subClient of clientMap) {
-        const methodHierarchies = getMethodHierarchiesMap(context, subClient[1]);
-        for (const [prefixKey, operations] of methodHierarchies) {
-            const prefixes = prefixKey.split("/");
-            for (const op of operations) {
-                const { shouldWrap, isBinary } = checkWrapNonModelReturn(context, op);
-                if (!shouldWrap) {
-                    continue;
-                }
-                if (!modelsFile) {
-                    modelsFile = outputProject.createSourceFile(filepath);
-                }
-                const method = [prefixes, op];
-                const typeAlias = buildNonModelResponseTypeDeclaration(context, method, isBinary);
-                addDeclaration(modelsFile, typeAlias, refkey(op, "response"));
-            }
-        }
-    }
-}
-function emitType(context, type, sourceFile) {
-    if (type.kind === "model") {
-        if (isAzureCoreErrorType(context.program, type.__raw)) {
-            return;
-        }
-        if (isOrExtendsHttpFile(context.program, type.__raw)) {
-            return;
-        }
-        if (!type.usage ||
-            (type.usage !== undefined &&
-                (type.usage & UsageFlags.Output) !== UsageFlags.Output &&
-                (type.usage & UsageFlags.Input) !== UsageFlags.Input &&
-                (type.usage & UsageFlags.Exception) !== UsageFlags.Exception)) {
-            return;
-        }
-        if (!type.name && type.isGeneratedName) {
-            // TODO: https://github.com/Azure/typespec-azure/issues/1713 and https://github.com/microsoft/typespec/issues/4815
-            // throw new Error(`Generation of anonymous types`);
-            return;
-        }
-        const modelInterface = buildModelInterface(context, type);
-        if (type.discriminatorProperty) {
-            modelInterface.properties
-                ?.filter((p) => {
-                return p.name === normalizeModelPropertyName(context, type.discriminatorProperty);
-            })
-                .map((p) => {
-                p.docs?.push(`The discriminator possible values: ${Object.keys(type.discriminatedSubtypes ?? {}).join(", ")}`);
-                return p;
-            });
-        }
-        addDeclaration(sourceFile, modelInterface, type);
-        const modelPolymorphicType = buildModelPolymorphicType(context, type);
-        if (modelPolymorphicType) {
-            addSerializationFunctions(context, type, sourceFile, true);
-            addDeclaration(sourceFile, modelPolymorphicType, refkey(type, "polymorphicType"));
-        }
-        addSerializationFunctions(context, type, sourceFile);
-    }
-    else if (type.kind === "enum") {
-        if (!type.usage) {
-            return;
-        }
-        const apiVersionEnumOnly = type.usage === UsageFlags.ApiVersionEnum;
-        // Skip known api version enums for multi-service scenarios as users are not allowed to set api versions
-        if (apiVersionEnumOnly && context.rlcOptions?.isMultiService) {
-            return;
-        }
-        const inputUsage = (type.usage & UsageFlags.Input) === UsageFlags.Input;
-        const outputUsage = (type.usage & UsageFlags.Output) === UsageFlags.Output;
-        const exceptionUsage = (type.usage & UsageFlags.Exception) === UsageFlags.Exception;
-        if (!(inputUsage || outputUsage || apiVersionEnumOnly || exceptionUsage)) {
-            return;
-        }
-        const [enumType, knownValuesEnum] = buildEnumTypes(context, type, isExtensibleEnum(context, type));
-        if (enumType.name.startsWith("_")) {
-            // skip enum generation for internal enums
-            return;
-        }
-        if (apiVersionEnumOnly) {
-            // generate known values enum only for api version enums
-            addDeclaration(sourceFile, knownValuesEnum, refkey(knownValuesEnum.name, "knownValues"));
-        }
-        else {
-            if (isExtensibleEnum(context, type)) {
-                addDeclaration(sourceFile, knownValuesEnum, refkey(type, "knownValues"));
-            }
-            addDeclaration(sourceFile, enumType, type);
-        }
-    }
-    else if (type.kind === "union") {
-        const unionType = buildUnionType(context, type);
-        addDeclaration(sourceFile, unionType, type);
-        addSerializationFunctions(context, type, sourceFile);
-    }
-    else if (type.kind === "dict") {
-        addDeclaration(sourceFile, normalizeModelName(context, type), type);
-        addSerializationFunctions(context, type, sourceFile);
-    }
-    else if (type.kind === "array") {
-        addDeclaration(sourceFile, normalizeModelName(context, type), type);
-        addSerializationFunctions(context, type, sourceFile);
-    }
-    else if (type.kind === "nullable") {
-        const nullableType = buildNullableType(context, type);
-        addDeclaration(sourceFile, nullableType, type);
-    }
-}
-export function getApiVersionEnum(context) {
-    // Skip api version enum for multi-service scenarios since each service may have different versions
-    if (context.rlcOptions?.isMultiService) {
-        return;
-    }
-    const apiVersionEnum = context.sdkPackage.enums.find((e) => e.usage === UsageFlags.ApiVersionEnum);
-    if (!apiVersionEnum) {
-        return;
-    }
-    return apiVersionEnum;
-}
-export function getModelsPath(sourceRoot, modelNamespace = []) {
-    return path.join(...[
-        sourceRoot,
-        "models",
-        ...modelNamespace.map((n) => normalizeName(n, NameType.File)),
-        `models.ts`,
-    ]);
-}
-export function getModelNamespaces(context, model) {
-    if (model.kind === "model" || model.kind === "enum" || model.kind === "union") {
-        if ((model.namespace ?? "").startsWith("Azure.ResourceManager") ||
-            (model.namespace ?? "").startsWith("Azure.Core") ||
-            (model.crossLanguageDefinitionId ?? "").startsWith("TypeSpec.Rest.Resource") ||
-            (model.crossLanguageDefinitionId ?? "") === "TypeSpec.Http.File" // filter out the TypeSpec.Http.File model similar like what java does here https://github.com/microsoft/typespec/blob/main/packages/http-client-java/emitter/src/code-model-builder.ts#L2589
-        ) {
-            return [];
-        }
-        const segments = model.namespace.split(".");
-        // Keep full namespace segments if multiple services are present because there isn't a root namespace to trim
-        if (context.rlcOptions?.isMultiService) {
-            return segments;
-        }
-        const allServiceNamespaces = context.allServiceNamespaces ?? listAllServiceNamespaces(context);
-        const deepestNamespace = getNamespaceFullName(allServiceNamespaces[0]);
-        const rootNamespace = deepestNamespace.split(".") ?? [];
-        if (segments.length > rootNamespace.length) {
-            while (segments[0] === rootNamespace[0]) {
-                segments.shift();
-                rootNamespace.shift();
-            }
-            return segments;
-        }
-        return [];
-    }
-    else if (model.kind === "array" || model.kind === "dict") {
-        return getModelNamespaces(context, model.valueType);
-    }
-    else if (model.kind === "nullable") {
-        return getModelNamespaces(context, model.type);
-    }
-    return [];
-}
-/**
- * Checks if a model type appears as a nested property (directly or as an array element)
- * inside any other XML model in the emit queue. XmlObject serializers/deserializers
- * are only needed for models that are nested inside other models.
- */
-function isNestedInXmlModel(targetModel) {
-    for (const type of emitQueue) {
-        if (type.kind !== "model" || type === targetModel) {
-            continue;
-        }
-        if (!hasXmlSerialization(type)) {
-            continue;
-        }
-        // Check properties of this model and all ancestors
-        for (const property of getModelAndAncestorProperties(type)) {
-            const propType = property.type;
-            if (propType.kind === "model" && propType === targetModel) {
-                return true;
-            }
-            if (propType.kind === "array" &&
-                propType.valueType.kind === "model" &&
-                propType.valueType === targetModel) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-/**
- * Gets all properties from a model and its ancestors (base models).
- */
-function getModelAndAncestorProperties(type) {
-    const properties = [];
-    let current = type;
-    while (current) {
-        for (const prop of current.properties) {
-            if (prop.kind === "property") {
-                properties.push(prop);
-            }
-        }
-        current = current.baseModel;
-    }
-    return properties;
-}
-function addSerializationFunctions(context, typeOrProperty, sourceFile, skipDiscriminatedUnionSuffix = false) {
-    const options = {
-        nameOnly: false,
-        skipDiscriminatedUnionSuffix,
-    };
-    // Add JSON serializers
-    const serializationFunction = typeOrProperty.kind === "property"
-        ? buildPropertySerializer(context, typeOrProperty, options)
-        : buildModelSerializer(context, typeOrProperty, options);
-    const serializerRefKey = refkey(typeOrProperty, "serializer");
-    const deserializerRefKey = refkey(typeOrProperty, "deserializer");
-    if (serializationFunction &&
-        typeof serializationFunction !== "string" &&
-        serializationFunction.name) {
-        addDeclaration(sourceFile, serializationFunction, serializerRefKey);
-    }
-    const deserializationFunction = typeOrProperty.kind === "property"
-        ? buildPropertyDeserializer(context, typeOrProperty, options)
-        : buildModelDeserializer(context, typeOrProperty, options);
-    if (deserializationFunction &&
-        typeof deserializationFunction !== "string" &&
-        deserializationFunction.name) {
-        addDeclaration(sourceFile, deserializationFunction, deserializerRefKey);
-    }
-    // Add XML serializers if the type has XML serialization options
-    if (typeOrProperty.kind === "model" && hasXmlSerialization(typeOrProperty)) {
-        const xmlSerializerRefKey = refkey(typeOrProperty, "xmlSerializer");
-        const xmlDeserializerRefKey = refkey(typeOrProperty, "xmlDeserializer");
-        const xmlSerializationFunction = buildXmlModelSerializer(context, typeOrProperty, options);
-        if (xmlSerializationFunction &&
-            typeof xmlSerializationFunction !== "string" &&
-            xmlSerializationFunction.name) {
-            addDeclaration(sourceFile, xmlSerializationFunction, xmlSerializerRefKey);
-        }
-        const xmlDeserializationFunction = buildXmlModelDeserializer(context, typeOrProperty, options);
-        if (xmlDeserializationFunction &&
-            typeof xmlDeserializationFunction !== "string" &&
-            xmlDeserializationFunction.name) {
-            addDeclaration(sourceFile, xmlDeserializationFunction, xmlDeserializerRefKey);
-        }
-        // Only generate XML object serializer/deserializer for models that are
-        // actually nested as properties inside other XML models
-        if (isNestedInXmlModel(typeOrProperty)) {
-            const xmlObjectSerializerRefKey = refkey(typeOrProperty, "xmlObjectSerializer");
-            const xmlObjectDeserializerRefKey = refkey(typeOrProperty, "xmlObjectDeserializer");
-            const xmlObjectSerializationFunction = buildXmlObjectModelSerializer(context, typeOrProperty, options);
-            if (xmlObjectSerializationFunction &&
-                typeof xmlObjectSerializationFunction !== "string" &&
-                xmlObjectSerializationFunction.name) {
-                addDeclaration(sourceFile, xmlObjectSerializationFunction, xmlObjectSerializerRefKey);
-            }
-            const xmlObjectDeserializationFunction = buildXmlObjectModelDeserializer(context, typeOrProperty, options);
-            if (xmlObjectDeserializationFunction &&
-                typeof xmlObjectDeserializationFunction !== "string" &&
-                xmlObjectDeserializationFunction.name) {
-                addDeclaration(sourceFile, xmlObjectDeserializationFunction, xmlObjectDeserializerRefKey);
-            }
-        }
-    }
-}
-function buildUnionType(context, type) {
-    const unionDeclaration = {
-        kind: StructureKind.TypeAlias,
-        name: normalizeModelName(context, type),
-        isExported: true,
-        type: type.variantTypes.map((v) => getTypeExpression(context, v)).join(" | "),
-    };
-    unionDeclaration.docs = [type.doc ?? `Alias for ${unionDeclaration.name}`];
-    return unionDeclaration;
-}
-function buildNullableType(context, type) {
-    const nullableDeclaration = {
-        kind: StructureKind.TypeAlias,
-        name: normalizeModelName(context, type),
-        isExported: true,
-        type: getTypeExpression(context, type.type) + " | null",
-    };
-    nullableDeclaration.docs = [type.doc ?? `Alias for ${nullableDeclaration.name}`];
-    return nullableDeclaration;
-}
-export function buildEnumTypes(context, type, reportMemberNameDiagnostic = false) {
-    const rawMembers = type.values.map((value) => emitEnumMember(context, value, reportMemberNameDiagnostic));
-    const enumDeclaration = {
-        kind: StructureKind.Enum,
-        name: `Known${normalizeModelName(context, type)}`,
-        isExported: true,
-        members: deduplicateEnumMemberNames(rawMembers),
-    };
-    const enumAsUnion = {
-        kind: StructureKind.TypeAlias,
-        name: normalizeModelName(context, type),
-        isExported: true,
-        type: !isExtensibleEnum(context, type)
-            ? type.values.map((v) => getTypeExpression(context, v)).join(" | ")
-            : getTypeExpression(context, type.valueType),
-    };
-    const docs = type.doc ? type.doc : "Type of " + enumAsUnion.name;
-    enumAsUnion.docs =
-        isExtensibleEnum(context, type) && type.doc
-            ? [getExtensibleEnumDescription(context, type) ?? docs]
-            : [docs];
-    enumDeclaration.docs = type.doc
-        ? [type.doc]
-        : [`Known values of {@link ${type.name}} that the service accepts.`];
-    return [enumAsUnion, enumDeclaration];
-}
-function getExtensibleEnumDescription(context, model) {
-    if (model.isFixed && model.name && model.values) {
-        return;
-    }
-    const valueDescriptions = model.values
-        .map((v) => `**${v.value}**${v.doc ? `: ${v.doc}` : ""}`)
-        .join(` \\\n`)
-        // Escape the character / to make sure we don't incorrectly announce a comment blocks /** */
-        .replace(/^\//g, "\\/")
-        .replace(/([^\\])(\/)/g, "$1\\/");
-    const enumLink = `{@link Known${normalizeModelName(context, model)}} can be used interchangeably with ${normalizeModelName(context, model)},\n this enum contains the known values that the service supports.`;
-    return [
-        `${model.doc} \\`,
-        enumLink,
-        `### Known values supported by the service`,
-        valueDescriptions,
-    ].join(" \n");
-}
-/**
- * Deduplicates enum member names by appending a numeric suffix (_1, _2, ...)
- * to all members that share the same normalized name.
- * This handles cases where different values (e.g. "10" and "1.0") normalize
- * to the same identifier.
- */
-function deduplicateEnumMemberNames(members) {
-    const nameCount = new Map();
-    for (const member of members) {
-        const name = member.name;
-        nameCount.set(name, (nameCount.get(name) ?? 0) + 1);
-    }
-    const nameCurrentIndex = new Map();
-    return members.map((member) => {
-        const name = member.name;
-        if ((nameCount.get(name) ?? 0) > 1) {
-            const index = (nameCurrentIndex.get(name) ?? 0) + 1;
-            nameCurrentIndex.set(name, index);
-            return { ...member, name: `${name}_${index}` };
-        }
-        return member;
-    });
-}
-function emitEnumMember(context, member, reportMemberNameDiagnostic = false) {
-    const shouldNormalizeName = !member.name.startsWith("$DO_NOT_NORMALIZE$");
-    const enumTypeName = normalizeName(member.enumType.name, NameType.Interface, true);
-    let normalizedMemberName = context.rlcOptions?.ignoreEnumMemberNameNormalize
-        ? fixLeadingNumber(member.name, NameType.EnumMemberName) // need to fix the leading number also for enum member
-        : normalizeName(member.name, NameType.EnumMemberName, true);
-    // If the member name starts with _ due to a leading digit (not because the original has _),
-    // replace the _ prefix with either "V" (for API version enums) or the enum type name.
-    if (shouldNormalizeName &&
-        normalizedMemberName.toLowerCase().startsWith("_") &&
-        !member.name.toLowerCase().startsWith("_")) {
-        const isApiVersionEnum = (member.enumType.usage & UsageFlags.ApiVersionEnum) === UsageFlags.ApiVersionEnum;
-        const prefix = isApiVersionEnum ? "V" : enumTypeName;
-        normalizedMemberName = prefix + normalizedMemberName.slice(1);
-        if (reportMemberNameDiagnostic) {
-            reportDiagnostic(context.program, {
-                code: "prefix-adding-in-enum-member",
-                format: {
-                    memberName: member.name,
-                    normalizedName: normalizedMemberName,
-                    enumTypeName,
-                },
-                target: NoTarget,
-            });
-        }
-    }
-    const memberStructure = {
-        kind: StructureKind.EnumMember,
-        name: normalizedMemberName,
-        value: member.value,
-    };
-    if (member.doc) {
-        memberStructure.docs = [member.doc];
-    }
-    else {
-        // Provide default documentation using the enum value when no explicit doc exists
-        memberStructure.docs = [String(member.value)];
-    }
-    return memberStructure;
-}
-function buildModelInterface(context, type) {
-    const flattenPropertySet = new Set();
-    // For non-input models (output-only, exception, etc.), filter out metadata
-    // properties (@header, @query, @path) since they are deserialized separately.
-    // For input models, keep metadata properties — users need to pass them.
-    const hasInputUsage = (type.usage & UsageFlags.Input) === UsageFlags.Input;
-    const interfaceStructure = {
-        kind: StructureKind.Interface,
-        name: normalizeModelName(context, type, NameType.Interface, true),
-        isExported: true,
-        properties: type.properties
-            .filter((p) => {
-            if (!hasInputUsage && p.__raw && isMetadata(context.program, p.__raw)) {
-                return false;
-            }
-            // Skip required metadata properties with Read-only visibility for ARM as they are not intended to be in the model
-            // These properties are not be generated no matter they are in input or output models in most cases in HLC
-            // Only skip properties that have exclusively Read visibility to avoid stripping @path properties
-            // on parameter bag models that also carry other visibility flags (e.g. Create/Update)
-            if (context.arm &&
-                p.__raw &&
-                isMetadata(context.program, p.__raw) &&
-                p.visibility?.length === 1 &&
-                p.visibility?.includes(Visibility.Read)) {
-                return false;
-            }
-            // filter out the flatten property to be processed later
-            if (p.flatten && p.type.kind === "model") {
-                flattenPropertySet.add(p);
-                return false;
-            }
-            return true;
-        })
-            .map((p) => {
-            return buildModelProperty(context, p, type);
-        }),
-    };
-    for (const flatten of flattenPropertySet.keys()) {
-        const conflictMap = useContext("sdkTypes").flattenProperties.get(flatten)?.conflictMap;
-        const allProperties = getAllProperties(context, flatten.type, getAllAncestors(flatten.type));
-        interfaceStructure.properties.push(...allProperties.map((p) => {
-            // when the flattened property is optional, all its child properties should be optional too
-            const property = getPropertyWithOverrides(p, {
-                allOptional: flatten.optional,
-                propertyRenames: conflictMap,
-            });
-            return buildModelProperty(context, property, type);
-        }));
-    }
-    // Add properties from @clientOption("header", ...) that don't already exist in the model
-    const headerOptions = getHeaderClientOptions(type);
-    if (headerOptions.length > 0) {
-        const existingNames = new Set(interfaceStructure.properties.map((p) => p.name));
-        for (const opt of headerOptions) {
-            if (!existingNames.has(opt.propertyName)) {
-                interfaceStructure.properties.push({
-                    kind: StructureKind.PropertySignature,
-                    name: opt.propertyName,
-                    type: "string",
-                    hasQuestionToken: true,
-                });
-            }
-        }
-    }
-    if (type.baseModel) {
-        const parentReference = getModelExpression(context, type.baseModel, {
-            skipPolymorphicUnion: true,
-        });
-        interfaceStructure.extends = [parentReference];
-    }
-    if (type.additionalProperties) {
-        addExtendedDictInfo(context, type, interfaceStructure);
-    }
-    interfaceStructure.docs = [type.doc ?? "model interface " + interfaceStructure.name];
-    return interfaceStructure;
-}
-function addExtendedDictInfo(context, model, modelInterface) {
-    const additionalPropertiesType = model.additionalProperties
-        ? getTypeExpression(context, model.additionalProperties)
-        : undefined;
-    if (context.rlcOptions?.compatibilityMode) {
-        const ancestors = getAllAncestors(model);
-        const properties = getAllProperties(context, model, ancestors);
-        let anyType = true;
-        if (!additionalPropertiesType) {
-            // case 1: if additionalProperties is not defined, we should use any type
-            anyType = true;
-        }
-        else if (properties.length === 0) {
-            // case 2: if additionalProperties is defined and model.properties is empty, we should use additionalProperties type
-            anyType = false;
-        }
-        else {
-            // case 3: if additionalProperties is defined and model.properties is not empty, we should check if all properties are compatible with additionalProperties type
-            anyType = !properties.every((p) => {
-                return additionalPropertiesType?.includes(getTypeExpression(context, p.type));
-            });
-        }
-        if (!modelInterface.extends) {
-            modelInterface.extends = [];
-        }
-        modelInterface.extends.push(`Record<string, ${anyType ? "any" : additionalPropertiesType}>`);
-    }
-    else {
-        const additionalPropertiesType = model.additionalProperties
-            ? getTypeExpression(context, model.additionalProperties)
-            : undefined;
-        const name = getAdditionalPropertiesName(context, model);
-        if (name !== "additionalProperties") {
-            // report diagnostic for additionalProperties
-            reportDiagnostic(context.program, {
-                code: "property-name-conflict",
-                format: {
-                    propertyName: "additionalProperties",
-                },
-                target: NoTarget,
-            });
-        }
-        if (!modelInterface.properties) {
-            modelInterface.properties = [];
-        }
-        modelInterface.properties.push({
-            name,
-            docs: ["Additional properties"],
-            hasQuestionToken: true,
-            isReadonly: false,
-            type: `Record<string, ${additionalPropertiesType ?? "any"}>`,
-        });
-    }
-}
-export function getAdditionalPropertiesName(context, model) {
-    const ancestors = getAllAncestors(model);
-    const properties = getAllProperties(context, model, ancestors);
-    const nameConflict = properties.find((p) => p.name === "additionalProperties");
-    return nameConflict ? "additionalPropertiesBag" : "additionalProperties";
-}
-export function normalizeModelName(context, type, nameType = NameType.Interface, skipPolymorphicUnionSuffix = false, rawModelName) {
-    if (type.kind === "array") {
-        if (rawModelName) {
-            return `${normalizeModelName(context, type.valueType, nameType, skipPolymorphicUnionSuffix, rawModelName)}Array`;
-        }
-        return `Array<${normalizeModelName(context, type.valueType, nameType)}>`;
-    }
-    else if (type.kind === "dict") {
-        if (rawModelName) {
-            return `${normalizeModelName(context, type.valueType, nameType, skipPolymorphicUnionSuffix, rawModelName)}Record`;
-        }
-        return `Record<string, ${normalizeModelName(context, type.valueType, nameType)}>`;
-    }
-    if (type.kind !== "model" &&
-        type.kind !== "enum" &&
-        type.kind !== "union" &&
-        type.kind !== "nullable") {
-        return getTypeExpression(context, type);
-    }
-    const segments = getModelNamespaces(context, type);
-    let unionSuffix = "";
-    if (!skipPolymorphicUnionSuffix) {
-        if (type.kind === "model" && isDiscriminatedUnion(type)) {
-            unionSuffix = "Union";
-        }
-    }
-    const namespacePrefix = context.rlcOptions?.enableModelNamespace ? segments.join("") : "";
-    const internalModelPrefix = (isPagedResultModel(context, type) && !pagedModelsUsedInNonPagingOps.has(type)) ||
-        type.isGeneratedName
-        ? "_"
-        : "";
-    return `${internalModelPrefix}${normalizeName(namespacePrefix + type.name, nameType, true)}${unionSuffix}`;
-}
-function buildModelPolymorphicType(context, type) {
-    // Only include direct subtypes in this union
-    const directSubtypes = getDirectSubtypes(type);
-    if (directSubtypes.length === 0) {
-        return undefined;
-    }
-    const typeDeclaration = {
-        kind: StructureKind.TypeAlias,
-        name: `${normalizeModelName(context, type, NameType.Interface, true)}Union`,
-        isExported: true,
-        type: directSubtypes
-            .filter((p) => {
-            return (p.usage !== undefined &&
-                ((p.usage & UsageFlags.Output) === UsageFlags.Output ||
-                    (p.usage & UsageFlags.Input) === UsageFlags.Input));
-        })
-            .map((t) => getTypeExpression(context, t))
-            .join(" | "),
-    };
-    typeDeclaration.docs = [`Alias for ${typeDeclaration.name}`];
-    typeDeclaration.type += ` | ${getModelExpression(context, type, {
-        skipPolymorphicUnion: true,
-    })}`;
-    return typeDeclaration;
-}
-function buildModelProperty(context, property, model) {
-    const normalizedPropName = normalizeModelPropertyName(context, property);
-    if (!context.rlcOptions?.ignorePropertyNameNormalize &&
-        normalizedPropName !== `"${property.name}"`) {
-        reportDiagnostic(context.program, {
-            code: "property-name-normalized",
-            format: {
-                propertyName: property.name,
-                normalizedName: normalizedPropName,
-            },
-            target: NoTarget,
-        });
-    }
-    let typeExpression;
-    const allDiscriminatorValues = getAllDiscriminatedValues(model, property);
-    // We need refine the discriminator property if
-    // 1. it is discriminated union
-    // 2. it has other discriminator values except itself
-    if (isDiscriminatedUnion(model) && allDiscriminatorValues.length > 1) {
-        typeExpression = allDiscriminatorValues.map((value) => `"${value}"`).join(" | ");
-    }
-    else if (property.kind === "property" && property.serializationOptions.multipart?.isFilePart) {
-        typeExpression = getMultipartFileTypeExpression(context, property);
-    }
-    else {
-        typeExpression = getTypeExpression(context, property.type, {
-            isOptional: property.optional,
-        });
-    }
-    const propertyStructure = {
-        kind: StructureKind.PropertySignature,
-        name: normalizedPropName,
-        type: typeExpression,
-        hasQuestionToken: property.optional,
-        isReadonly: isReadOnly(property),
-    };
-    if (property.doc) {
-        propertyStructure.docs = [property.doc];
-    }
-    return propertyStructure;
-}
-export function visitPackageTypes(context) {
-    const { sdkPackage } = context;
-    emitQueue.clear();
-    flattenPropertyModelMap.clear();
-    pagedModelsUsedInNonPagingOps.clear();
-    // Add all models in the package to the emit queue
-    for (const model of sdkPackage.models) {
-        visitType(context, model);
-    }
-    for (const union of sdkPackage.unions) {
-        visitType(context, union);
-    }
-    // Add all enums to the queue
-    for (const enumType of sdkPackage.enums) {
-        if (!emitQueue.has(enumType)) {
-            emitQueue.add(enumType);
-        }
-    }
-    // Visit the clients to discover all models
-    for (const client of sdkPackage.clients) {
-        visitClient(context, client);
-    }
-}
-function visitClient(context, client) {
-    // TODO: include the client parameters
-    // https://github.com/Azure/autorest.typescript/issues/3148
-    // Comment this out for now, as client initialization is not used in the generated code
-    getAllOperationsFromClient(client).forEach((method) => visitClientMethod(context, method));
-}
-function visitClientMethod(context, method) {
-    switch (method.kind) {
-        case "lro":
-        case "paging":
-        case "lropaging":
-        case "basic":
-            visitMethod(context, method);
-            visitOperation(context, method.operation);
-            break;
-        default:
-            reportDiagnostic(context.program, {
-                code: "unknown-sdk-method-kind",
-                format: {
-                    methodKind: method.kind,
-                },
-                target: NoTarget,
-            });
-            return; // Skip processing this method but continue with others
-    }
-}
-function visitOperation(context, operation) {
-    // Visit the request
-    visitType(context, operation.bodyParam?.type);
-    // Visit the response
-    operation.exceptions.forEach((exception) => visitType(context, exception.type));
-    operation.parameters.forEach((parameter) => {
-        visitType(context, parameter.type);
-    });
-    operation.responses.forEach((response) => visitType(context, response.type));
-}
-function visitMethod(context, method) {
-    // Visit the request
-    method.parameters.forEach((parameter) => {
-        visitType(context, parameter.type);
-    });
-    visitType(context, method.response.type);
-    trackPagedModelInNonPagingMethod(context, method);
-}
-/**
- * If a non-paging method's direct response type is a paged result model,
- * mark it so that normalizeModelName keeps it public (no "_" prefix).
- */
-function trackPagedModelInNonPagingMethod(context, method) {
-    if (method.kind !== "basic" && method.kind !== "lro")
-        return;
-    const respType = method.response.type;
-    if (respType && isPagedResultModel(context, respType)) {
-        pagedModelsUsedInNonPagingOps.add(respType);
-    }
-}
-function visitType(context, type) {
-    if (!type) {
-        return;
-    }
-    if (emitQueue.has(type)) {
-        return;
-    }
-    emitQueue.add(type);
-    if (type.kind === "model") {
-        const externalModel = getExternalModel(type);
-        if (externalModel) {
-            return;
-        }
-        if (type.additionalProperties) {
-            visitType(context, type.additionalProperties);
-        }
-        for (const property of type.properties) {
-            if (!emitQueue.has(property.type)) {
-                visitType(context, property.type);
-            }
-            if (property.flatten && property.type.kind === "model") {
-                flattenPropertyModelMap.set(property, type);
-            }
-        }
-        if (type.discriminatedSubtypes) {
-            for (const subType of Object.values(type.discriminatedSubtypes)) {
-                if (!emitQueue.has(subType)) {
-                    visitType(context, subType);
-                }
-            }
-        }
-    }
-    if (type.kind === "array") {
-        if (!emitQueue.has(type.valueType)) {
-            visitType(context, type.valueType);
-        }
-    }
-    if (type.kind === "dict") {
-        if (!emitQueue.has(type.valueType)) {
-            visitType(context, type.valueType);
-        }
-    }
-    if (type.kind === "union") {
-        emitQueue.add(type);
-        for (const value of type.variantTypes) {
-            if (!emitQueue.has(value)) {
-                visitType(context, value);
-            }
-        }
-    }
-    if (type.kind === "nullable") {
-        emitQueue.add(type);
-        if (!emitQueue.has(type.type)) {
-            visitType(context, type.type);
-        }
-    }
-}
-//# sourceMappingURL=emitModels.js.map