@azure-tools/typespec-ts 0.33.0 → 0.34.0

package/dist/src/modular/emitModels.js

@@ -1,298 +1,493 @@
-import * as path from "path";
-import { addImportsToFiles, getImportSpecifier } from "@azure-tools/rlc-common";
+import { StructureKind } from "ts-morph";
+import { NameType, normalizeName } from "@azure-tools/rlc-common";
+import { UsageFlags, isReadOnly } from "@azure-tools/typespec-client-generator-core";
+import { getExternalModel, getModelExpression } from "./type-expressions/get-model-expression.js";
+import { addDeclaration } from "../framework/declaration.js";
 import { addImportBySymbol } from "../utils/importHelper.js";
+import { buildModelDeserializer } from "./serialization/buildDeserializerFunction.js";
 import { buildModelSerializer } from "./serialization/buildSerializerFunction.js";
-import { buildOperationOptions } from "./buildOperations.js";
-import { getDocsFromDescription } from "./helpers/docsHelpers.js";
-import { getModularModelFilePath } from "./helpers/namingHelpers.js";
-import { getType } from "./helpers/typeHelpers.js";
-import { toCamelCase } from "../utils/casingUtils.js";
-// ====== UTILITIES ======
-function isAzureCoreErrorSdkType(t) {
-    return (t.name &&
-        ["error", "errormodel", "innererror", "errorresponse"].includes(t.name.toLowerCase()) &&
-        t.coreTypeInfo === "ErrorType");
+import { extractPagedMetadataNested } from "../utils/operationUtil.js";
+import { getTypeExpression, normalizeModelPropertyName } from "./type-expressions/get-type-expression.js";
+import path from "path";
+import { refkey } from "../framework/refkey.js";
+import { useContext } from "../contextManager.js";
+import { isMetadata } from "@typespec/http";
+import { isAzureCoreErrorType, isAzureCoreLroType } from "../utils/modelUtils.js";
+import { isExtensibleEnum } from "./type-expressions/get-enum-expression.js";
+import { isDiscriminatedUnion } from "./serialization/serializeUtils.js";
+import { reportDiagnostic } from "../lib.js";
+import { NoTarget } from "@typespec/compiler";
+import { emitQueue } from "../framework/hooks/sdkTypes.js";
+function isGenerableType(type) {
+    return (type.kind === "model" ||
+        type.kind === "enum" ||
+        type.kind === "union" ||
+        type.kind === "dict" ||
+        type.kind === "array" ||
+        type.kind === "nullable");
 }
-function isAzureCoreLroSdkType(t) {
-    return (t.name &&
-        ["operationstate"].includes(t.name.toLowerCase()) &&
-        t.coreTypeInfo === "LroType");
-}
-function isAnonymousModel(t) {
-    return t.type === "model" && t.name === "";
-}
-export function isModelWithAdditionalProperties(t) {
-    return t.type === "dict" && t.name !== "Record";
-}
-function getCoreClientErrorType(name, coreClientTypes) {
-    const coreClientType = name === "Error" ? "ErrorModel" : name;
-    coreClientTypes.add(coreClientType);
-    return coreClientType;
-}
-function getCoreLroType(name, coreLroTypes) {
-    const coreLroType = name === "OperationState" ? "CoreOperationStatus" : name;
-    coreLroTypes.add(coreLroType);
-    return coreLroType;
+export function emitTypes(context, { sourceRoot }) {
+    const { sdkPackage } = context;
+    const outputProject = useContext("outputProject");
+    const modelsFilePath = getModelsPath(sourceRoot);
+    let sourceFile;
+    if (emitQueue.size > 0 &&
+        (sdkPackage.models.length > 0 || sdkPackage.enums.length > 0)) {
+        sourceFile = outputProject.createSourceFile(modelsFilePath);
+        if (!sourceFile) {
+            throw new Error(`Failed to create source file at ${modelsFilePath}`);
+        }
+    }
+    else {
+        return;
+    }
+    for (const type of emitQueue) {
+        if (!isGenerableType(type)) {
+            continue;
+        }
+        if (isAzureCoreLroType(type.__raw)) {
+            continue;
+        }
+        emitType(context, type, sourceFile);
+    }
+    if (sourceFile.getInterfaces().length === 0 &&
+        sourceFile.getTypeAliases().length === 0 &&
+        sourceFile.getEnums().length === 0) {
+        sourceFile.delete();
+        return;
+    }
+    addImportBySymbol("serializeRecord", sourceFile);
+    return sourceFile;
 }
-// ====== TYPE EXTRACTION ======
-function extractModels(codeModel) {
+function emitType(context, type, sourceFile) {
     var _a;
-    const models = codeModel.types.filter((t) => ((t.type === "model" || t.type === "enum") &&
-        !isAzureCoreErrorSdkType(t) &&
-        !isAzureCoreLroSdkType(t) &&
-        !isAnonymousModel(t)) ||
-        isModelWithAdditionalProperties(t));
-    for (const model of codeModel.types) {
-        if (model.type === "combined") {
-            for (const unionModel of (_a = model.types) !== null && _a !== void 0 ? _a : []) {
-                if (unionModel.type === "model") {
-                    models.push(unionModel);
-                }
+    if (type.kind === "model") {
+        if (isAzureCoreErrorType(context.program, type.__raw)) {
+            return;
+        }
+        if (!type.usage ||
+            (type.usage !== undefined &&
+                (type.usage & UsageFlags.Output) !== UsageFlags.Output &&
+                (type.usage & UsageFlags.Input) !== UsageFlags.Input)) {
+            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) {
+            (_a = modelInterface.properties) === null || _a === void 0 ? void 0 : _a.filter((p) => {
+                return (p.name ===
+                    normalizeModelPropertyName(context, type.discriminatorProperty));
+            }).map((p) => {
+                var _a, _b;
+                (_a = p.docs) === null || _a === void 0 ? void 0 : _a.push(`The discriminator possible values: ${Object.keys((_b = type.discriminatedSubtypes) !== null && _b !== void 0 ? _b : {}).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;
+        const inputUsage = (type.usage & UsageFlags.Input) === UsageFlags.Input;
+        const outputUsage = (type.usage & UsageFlags.Output) === UsageFlags.Output;
+        if (!(inputUsage || outputUsage || apiVersionEnumOnly)) {
+            return;
+        }
+        const [enumType, knownValuesEnum] = buildEnumTypes(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(type, "knownValues"));
+        }
+        else {
+            if (isExtensibleEnum(context, type)) {
+                addDeclaration(sourceFile, knownValuesEnum, refkey(type, "knownValues"));
             }
+            addDeclaration(sourceFile, enumType, type);
         }
     }
-    return models;
+    else if (type.kind === "union") {
+        const unionType = buildUnionType(context, type);
+        addDeclaration(sourceFile, unionType, type);
+        addSerializationFunctions(context, type, sourceFile);
+    }
+    else if (type.kind === "dict") {
+        addSerializationFunctions(context, type, sourceFile);
+    }
+    else if (type.kind === "array") {
+        addSerializationFunctions(context, type, sourceFile);
+    }
+}
+export function getApiVersionEnum(context) {
+    const apiVersionEnum = context.sdkPackage.enums.find((e) => e.usage === UsageFlags.ApiVersionEnum);
+    if (!apiVersionEnum) {
+        return;
+    }
+    return apiVersionEnum;
 }
-/**
- * Extracts all the aliases from the code model
- * 1. alias from polymorphic base model, where we need to use typescript union to combine all the sub models
- * 2. alias from unions, where we also need to use typescript union to combine all the union variants
- */
-export function extractAliases(codeModel) {
-    const models = codeModel.types.filter((t) => ((t.type === "model" || t.type === "combined") &&
-        t.alias &&
-        t.aliasType) ||
-        (isModelWithAdditionalProperties(t) && t.alias && t.aliasType));
-    return models;
+export function getModelsPath(sourceRoot) {
+    return path.join(...[sourceRoot, "models", `models.ts`]);
+}
+function addSerializationFunctions(context, type, sourceFile, skipDiscriminatedUnion = false) {
+    const serializationFunction = buildModelSerializer(context, type, skipDiscriminatedUnion);
+    if (serializationFunction &&
+        typeof serializationFunction !== "string" &&
+        serializationFunction.name &&
+        !sourceFile.getFunction(serializationFunction.name)) {
+        addDeclaration(sourceFile, serializationFunction, refkey(type, "serializer"));
+    }
+    const deserializationFunction = buildModelDeserializer(context, type, skipDiscriminatedUnion);
+    if (deserializationFunction &&
+        typeof deserializationFunction !== "string" &&
+        deserializationFunction.name &&
+        !sourceFile.getFunction(deserializationFunction.name)) {
+        addDeclaration(sourceFile, deserializationFunction, refkey(type, "deserializer"));
+    }
 }
-// ====== TYPE BUILDERS ======
-function buildEnumModel(model) {
+function buildUnionType(context, type) {
     var _a;
-    const valueType = ((_a = model.valueType) === null || _a === void 0 ? void 0 : _a.type) === "string" ? "string" : "number";
-    return {
-        name: model.name,
+    const unionDeclaration = {
+        kind: StructureKind.TypeAlias,
+        name: normalizeModelName(context, type),
         isExported: true,
-        docs: [...getDocsFromDescription(model.description)],
-        type: buildEnumType()
+        type: type.variantTypes
+            .map((v) => getTypeExpression(context, v))
+            .join(" | ")
     };
-    function buildEnumType() {
-        return model.isFixed || !model.isNonExhaustive
-            ? getEnumValues(" | ")
-            : valueType;
-    }
-    function getEnumValues(separator = ", ") {
-        var _a;
-        const splitWord = valueType === "string" ? `"` : ``;
-        return ((_a = model.values) !== null && _a !== void 0 ? _a : [])
-            .map((v) => `${splitWord}${v.value}${splitWord}`)
-            .join(separator);
-    }
+    unionDeclaration.docs = [(_a = type.doc) !== null && _a !== void 0 ? _a : `Alias for ${unionDeclaration.name}`];
+    return unionDeclaration;
 }
-export function buildModelInterface(model, cache) {
-    var _a, _b, _c;
-    const modelProperties = (_a = model.properties) !== null && _a !== void 0 ? _a : [];
-    const modelInterface = {
-        name: (_c = (_b = model.alias) !== null && _b !== void 0 ? _b : model.name) !== null && _c !== void 0 ? _c : "FIXMYNAME",
+export function buildEnumTypes(context, type) {
+    var _a;
+    const enumDeclaration = {
+        kind: StructureKind.Enum,
+        name: `Known${normalizeModelName(context, type)}`,
         isExported: true,
-        docs: getDocsFromDescription(model.description),
-        extends: [],
-        properties: (modelProperties !== null && modelProperties !== void 0 ? modelProperties : []).map((p) => {
-            const propertyMetadata = getType(p.type, p.format);
-            let propertyTypeName = propertyMetadata.name;
-            if (isAzureCoreErrorSdkType(p.type)) {
-                propertyTypeName = getCoreClientErrorType(propertyTypeName, cache.coreClientTypes);
-            }
-            if (isAzureCoreLroSdkType(p.type)) {
-                propertyTypeName = getCoreLroType(propertyTypeName, cache.coreLroTypes);
-            }
-            return {
-                name: `"${p.clientName}"`,
-                docs: getDocsFromDescription(p.description),
-                hasQuestionToken: p.optional,
-                isReadonly: p.readonly,
-                type: propertyTypeName
-            };
-        })
+        members: type.values.map(emitEnumMember)
     };
-    return modelInterface;
-}
-// ====== MAIN FUNCTIONS ======
-/**
- * This function creates the file containing all the models defined in TypeSpec
- */
-export function buildModels(subClient, codeModel) {
-    var _a, _b, _c;
-    // We are generating both models and enums here
-    const coreClientTypes = new Set();
-    const coreLroTypes = new Set();
-    // filter out the models/enums that are anonymous
-    const models = extractModels(codeModel).filter((m) => !!m.name);
-    const aliases = extractAliases(codeModel);
-    // Skip to generate models.ts if there is no any models
-    if (models.length === 0 && aliases.length === 0) {
-        return;
-    }
-    const modelsFile = codeModel.project.createSourceFile(getModularModelFilePath(codeModel, subClient));
-    for (const model of models) {
-        if (model.type === "enum") {
-            if (modelsFile.getTypeAlias(model.name)) {
-                // If the enum is already defined, we don't need to do anything
-                continue;
-            }
-            const enumAlias = buildEnumModel(model);
-            if (model.isNonExhaustive && model.name) {
-                modelsFile.addEnum({
-                    name: `Known${model.name}`,
-                    isExported: true,
-                    members: (_b = (_a = model.values) === null || _a === void 0 ? void 0 : _a.map((v) => ({
-                        name: v.name,
-                        value: v.value,
-                        docs: v.description ? [v.description] : [v.name]
-                    }))) !== null && _b !== void 0 ? _b : [],
-                    docs: [
-                        `Known values of {@link ${model.name}} that the service accepts.`
-                    ]
-                });
-                const description = getExtensibleEnumDescription(model);
-                if (description) {
-                    enumAlias.docs = [description];
-                }
-            }
-            modelsFile.addTypeAlias(enumAlias);
-        }
-        else {
-            const modelInterface = buildModelInterface(model, {
-                coreClientTypes,
-                coreLroTypes
-            });
-            (_c = model.parents) === null || _c === void 0 ? void 0 : _c.forEach((p) => { var _a; return modelInterface.extends.push((_a = p.alias) !== null && _a !== void 0 ? _a : getType(p, p.format).name); });
-            if (isModelWithAdditionalProperties(model)) {
-                addExtendedDictInfo(model, modelInterface, codeModel.modularOptions.compatibilityMode);
-            }
-            if (!modelsFile.getInterface(modelInterface.name)) {
-                modelsFile.addInterface(modelInterface);
-            }
-            // Generate a serializer function next to each model
-            const serializerFunction = buildModelSerializer(model, codeModel.runtimeImports);
-            if (serializerFunction &&
-                !modelsFile.getFunction(toCamelCase(modelInterface.name + "Serializer"))) {
-                modelsFile.addStatements(serializerFunction);
-            }
-            addImportBySymbol("serializeRecord", modelsFile);
-            modelsFile.fixUnusedIdentifiers();
-        }
-    }
-    const projectRootFromModels = codeModel.clients.length > 1 ? "../.." : "../";
-    addImportsToFiles(codeModel.runtimeImports, modelsFile, {
-        serializerHelpers: path.posix.join(projectRootFromModels, "helpers", "serializerHelpers.js")
-    });
-    if (coreClientTypes.size > 0) {
-        modelsFile.addImportDeclarations([
-            {
-                moduleSpecifier: getImportSpecifier("restClient", codeModel.runtimeImports),
-                namedImports: Array.from(coreClientTypes)
-            }
-        ]);
-    }
-    if (coreLroTypes.size > 0) {
-        modelsFile.addImportDeclarations([
-            {
-                moduleSpecifier: getImportSpecifier("azureCoreLro", codeModel.runtimeImports),
-                namedImports: Array.from(coreLroTypes).map((t) => t === "CoreOperationStatus"
-                    ? "OperationStatus as CoreOperationStatus"
-                    : t)
-            }
-        ]);
-    }
-    aliases.forEach((alias) => {
-        modelsFile.addTypeAlias(buildModelTypeAlias(alias));
-        if (!models.includes(alias)) {
-            // Generate a serializer function next to each model
-            const serializerFunction = buildModelSerializer(alias, codeModel.runtimeImports);
-            if (serializerFunction) {
-                modelsFile.addStatements(serializerFunction);
-            }
-        }
-    });
-    return modelsFile;
+    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
+            ? [(_a = getExtensibleEnumDescription(type)) !== null && _a !== void 0 ? _a : docs]
+            : [docs];
+    enumDeclaration.docs = type.doc
+        ? [type.doc]
+        : [`Known values of {@link ${type.name}} that the service accepts.`];
+    return [enumAsUnion, enumDeclaration];
 }
 function getExtensibleEnumDescription(model) {
-    if (!(model.isNonExhaustive && model.name && model.values)) {
+    if (model.isFixed && model.name && model.values) {
         return;
     }
     const valueDescriptions = model.values
-        .map((v) => `**${v.value}**${v.description ? `: ${v.description}` : ""}`)
+        .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${model.name}} can be used interchangeably with ${model.name},\n this enum contains the known values that the service supports.`;
     return [
-        `${model.description} \\`,
+        `${model.doc} \\`,
         enumLink,
         `### Known values supported by the service`,
         valueDescriptions
     ].join(" \n");
 }
-function addExtendedDictInfo(model, modelInterface, compatibilityMode = false) {
+function emitEnumMember(member) {
+    const memberStructure = {
+        kind: StructureKind.EnumMember,
+        name: member.name,
+        value: member.value
+    };
+    if (member.doc) {
+        memberStructure.docs = [member.doc];
+    }
+    return memberStructure;
+}
+export function buildModelInterface(context, type) {
+    var _a;
+    const interfaceStructure = {
+        kind: StructureKind.Interface,
+        name: normalizeModelName(context, type, NameType.Interface, true),
+        isExported: true,
+        properties: type.properties
+            .filter((p) => !isMetadata(context.program, p.__raw))
+            .map((p) => {
+            return buildModelProperty(context, p);
+        })
+    };
+    if (type.baseModel) {
+        const parentReference = getModelExpression(context, type.baseModel, {
+            skipPolymorphicUnion: true
+        });
+        interfaceStructure.extends = [parentReference];
+    }
+    if (type.additionalProperties) {
+        addExtendedDictInfo(context, type, interfaceStructure);
+    }
+    interfaceStructure.docs = [
+        (_a = type.doc) !== null && _a !== void 0 ? _a : "model interface " + interfaceStructure.name
+    ];
+    return interfaceStructure;
+}
+function addExtendedDictInfo(context, model, modelInterface) {
     var _a, _b, _c, _d, _e;
+    const additionalPropertiesType = model.additionalProperties
+        ? getTypeExpression(context, model.additionalProperties)
+        : undefined;
     if ((model.properties &&
         model.properties.length > 0 &&
-        model.elementType &&
+        model.additionalProperties &&
         ((_a = model.properties) === null || _a === void 0 ? void 0 : _a.every((p) => {
-            var _a;
-            return (_a = getType(model.elementType)) === null || _a === void 0 ? void 0 : _a.name.includes(getType(p.type).name);
+            return additionalPropertiesType === null || additionalPropertiesType === void 0 ? void 0 : additionalPropertiesType.includes(getTypeExpression(context, p.type));
         }))) ||
-        (((_b = model.properties) === null || _b === void 0 ? void 0 : _b.length) === 0 && model.elementType)) {
-        modelInterface.extends.push(`Record<string, ${(_c = getType(model.elementType).name) !== null && _c !== void 0 ? _c : "any"}>`);
+        (((_b = model.properties) === null || _b === void 0 ? void 0 : _b.length) === 0 && model.additionalProperties)) {
+        modelInterface.extends = [
+            ...((_c = modelInterface.extends) !== null && _c !== void 0 ? _c : []),
+            `Record<string, ${additionalPropertiesType !== null && additionalPropertiesType !== void 0 ? additionalPropertiesType : "any"}>`
+        ];
     }
-    else if (compatibilityMode) {
+    else if ((_d = context.rlcOptions) === null || _d === void 0 ? void 0 : _d.compatibilityMode) {
+        if (!modelInterface.extends) {
+            modelInterface.extends = [];
+        }
         modelInterface.extends.push(`Record<string, any>`);
     }
     else {
-        (_d = modelInterface.properties) === null || _d === void 0 ? void 0 : _d.push({
+        (_e = modelInterface.properties) === null || _e === void 0 ? void 0 : _e.push({
             name: "additionalProperties",
             docs: ["Additional properties"],
             hasQuestionToken: true,
             isReadonly: false,
-            type: `Record<string, ${(_e = getType(model.elementType).name) !== null && _e !== void 0 ? _e : "any"}>`
+            type: `Record<string, ${additionalPropertiesType !== null && additionalPropertiesType !== void 0 ? additionalPropertiesType : "any"}>`
         });
     }
 }
-export function buildModelTypeAlias(model) {
-    return {
-        name: model.name,
+export function normalizeModelName(context, type, nameType = NameType.Interface, skipPolymorphicUnionSuffix = false) {
+    var _a;
+    if (type.kind === "array") {
+        return `Array<${normalizeModelName(context, type.valueType, nameType)}>`;
+    }
+    else if (type.kind === "dict") {
+        return `Record<string, ${normalizeModelName(context, type.valueType, nameType)}>`;
+    }
+    if (type.kind !== "model" && type.kind !== "enum" && type.kind !== "union") {
+        return getTypeExpression(context, type);
+    }
+    const segments = type.crossLanguageDefinitionId.split(".");
+    segments.pop();
+    segments.shift();
+    segments.filter((segment) => segment !== context.sdkPackage.rootNamespace);
+    let unionSuffix = "";
+    if (!skipPolymorphicUnionSuffix) {
+        if (type.kind === "model" && isDiscriminatedUnion(type)) {
+            unionSuffix = "Union";
+        }
+    }
+    const namespacePrefix = ((_a = context.rlcOptions) === null || _a === void 0 ? void 0 : _a.enableModelNamespace)
+        ? segments.join("")
+        : "";
+    let internalModelPrefix = "";
+    if (type.__raw && type.__raw.kind === "Model") {
+        // TODO: this is temporary until we have a better way in tcgc to extract the paged metadata
+        // issue link https://github.com/Azure/typespec-azure/issues/1464
+        const page = extractPagedMetadataNested(context.program, type.__raw);
+        internalModelPrefix =
+            page && page.itemsSegments && page.itemsSegments.length > 0 ? "_" : "";
+    }
+    if (type.isGeneratedName) {
+        internalModelPrefix = "_";
+    }
+    return `${internalModelPrefix}${normalizeName(namespacePrefix + type.name + unionSuffix, nameType, true)}`;
+}
+function buildModelPolymorphicType(context, type) {
+    if (!type.discriminatedSubtypes) {
+        return undefined;
+    }
+    const discriminatedSubtypes = Object.values(type.discriminatedSubtypes);
+    const typeDeclaration = {
+        kind: StructureKind.TypeAlias,
+        name: `${normalizeName(type.name, NameType.Interface)}Union`,
         isExported: true,
-        docs: ["Alias for " + model.name],
-        type: model.aliasType
+        type: discriminatedSubtypes
+            .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;
 }
-export function buildModelsOptions(client, codeModel) {
+function buildModelProperty(context, property) {
     var _a;
-    const modelOptionsFile = codeModel.project.createSourceFile(path.join(codeModel.modularOptions.sourceRoot, (_a = client.subfolder) !== null && _a !== void 0 ? _a : "", `models/options.ts`), undefined, {
-        overwrite: true
-    });
-    for (const operationGroup of client.operationGroups) {
-        operationGroup.operations.forEach((o) => {
-            buildOperationOptions(o, modelOptionsFile);
+    const normalizedPropName = normalizeModelPropertyName(context, property);
+    if (!((_a = context.rlcOptions) === null || _a === void 0 ? void 0 : _a.ignorePropertyNameNormalize) &&
+        normalizedPropName !== `"${property.name}"`) {
+        reportDiagnostic(context.program, {
+            code: "property-name-normalized",
+            format: {
+                propertyName: property.name,
+                normalizedName: normalizedPropName
+            },
+            target: NoTarget
         });
     }
-    modelOptionsFile.addImportDeclarations([
-        {
-            moduleSpecifier: getImportSpecifier("restClient", codeModel.runtimeImports),
-            namedImports: ["OperationOptions"]
+    const propertyStructure = {
+        kind: StructureKind.PropertySignature,
+        name: normalizedPropName,
+        type: getTypeExpression(context, property.type),
+        hasQuestionToken: property.optional,
+        isReadonly: isReadOnly(property)
+    };
+    if (property.doc) {
+        propertyStructure.docs = [property.doc];
+    }
+    return propertyStructure;
+}
+export function visitPackageTypes(context) {
+    const { sdkPackage } = context;
+    emitQueue.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);
         }
-    ]);
-    modelOptionsFile
-        .getImportDeclarations()
-        .filter((id) => {
-        return (id.isModuleSpecifierRelative() &&
-            !id.getModuleSpecifierValue().endsWith(".js"));
-    })
-        .map((id) => {
-        id.setModuleSpecifier(id.getModuleSpecifierValue() + ".js");
-        return id;
+    }
+    // Visit the clients to discover all models
+    for (const client of sdkPackage.clients) {
+        visitClient(context, client);
+    }
+}
+function visitClient(context, client) {
+    // Comment this out for now, as client initialization is not used in the generated code
+    // visitType(client.initialization, emitQueue);
+    client.methods.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;
+        case "clientaccessor":
+            method.response.methods.forEach((responseMethod) => visitClientMethod(context, responseMethod));
+            method.parameters.forEach((parameter) => {
+                visitType(context, parameter.type);
+            });
+            break;
+        default:
+            throw new Error(`Unknown sdk method kind: ${method.kind}`);
+    }
+}
+function visitOperation(context, operation) {
+    var _a;
+    // Visit the request
+    visitType(context, (_a = operation.bodyParam) === null || _a === void 0 ? void 0 : _a.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);
     });
-    return modelOptionsFile;
+    visitType(context, method.response.type);
+}
+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 (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