@azure-tools/typespec-ts 0.36.0 → 0.37.0

package/dist/src/modular/buildCodeModel.js

@@ -1,1489 +0,0 @@
-import { NoTarget, UsageFlags, getDiscriminator, getDoc, getEncode, getFriendlyName, getMaxItems, getMaxLength, getMaxValue, getMinItems, getMinLength, getMinValue, getPattern, getPropertyType, getSummary, getVisibility, isErrorModel, isNeverType, isNullType, isNumericType, isStringType, isTemplateDeclarationOrInstance, isType, isVoidType, listServices } from "@typespec/compiler";
-import { getAuthentication, getServers, isSharedRoute } from "@typespec/http";
-import { NameType, buildRuntimeImports, isAzurePackage, normalizeName } from "@azure-tools/rlc-common";
-import { getAllModels, getClientNamespaceString, getClientType, getDefaultApiVersion, getHttpOperationWithCache, getLibraryName, getSdkUnion, getWireName, isApiVersion, listClients, listOperationGroups, listOperationsInOperationGroup } from "@azure-tools/typespec-client-generator-core";
-import { buildCoreTypeInfo, getBodyType, getDefaultApiVersionString, getEffectiveSchemaType, isAzureCoreErrorType, isBodyRequired, isSchemaProperty } from "../utils/modelUtils.js";
-import { camelToSnakeCase, toCamelCase } from "../utils/casingUtils.js";
-import { extractPagedMetadataNested, getOperationGroupName, getOperationName, isBinaryPayload, isIgnoredHeaderParam, isLongRunningOperation, parseItemName, parseNextLinkName } from "../utils/operationUtil.js";
-import { getLroMetadata, getPagedResult } from "@azure-tools/typespec-azure-core";
-import { getAddedOnVersions } from "@typespec/versioning";
-import { getModelNamespaceName } from "../utils/namespaceUtils.js";
-import { getSupportedHttpAuth } from "../utils/credentialUtils.js";
-import { getType as getTypeName } from "./helpers/typeHelpers.js";
-import { reportDiagnostic } from "../lib.js";
-import { useContext } from "../contextManager.js";
-import { normalizeModelName } from "./emitModels.js";
-let CASING = "snake";
-function applyCasing(name, options = { casing: "snake" }) {
-    if (options.casing === "camel") {
-        return toCamelCase(name);
-    }
-    return camelToSnakeCase(name);
-}
-const typesMap = new Map();
-const simpleTypesMap = new Map();
-const endpointPathParameters = [];
-let methodApiVersionParam = undefined;
-let serverApiVersionParam = undefined;
-function isSimpleType(program, type) {
-    // these decorators can only work for simple type(int/string/float, etc)
-    if (type && (type.kind === "Scalar" || type.kind === "ModelProperty")) {
-        const funcs = [
-            getMinValue,
-            getMaxValue,
-            getMinLength,
-            getMaxLength,
-            getPattern,
-            getEncode
-        ];
-        for (const func of funcs) {
-            if (func(program, type)) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-function getDocStr(program, target) {
-    var _a;
-    return (_a = getDoc(program, target)) !== null && _a !== void 0 ? _a : "";
-}
-function isDiscriminator(context, type, propertyName) {
-    const discriminator = getDiscriminator(context.program, type);
-    if (discriminator && discriminator.propertyName === propertyName) {
-        return true;
-    }
-    return false;
-}
-function handleDiscriminator(context, type, usage) {
-    const discriminator = getDiscriminator(context.program, type);
-    if (discriminator) {
-        const discriminatorValues = [];
-        const aliases = [];
-        const discriminatedSubtypes = [];
-        let discriminatorTcgcType = undefined;
-        for (const childModel of type.derivedModels) {
-            const modelType = getType(context, childModel, { usage });
-            aliases.push(modelType.name);
-            for (const property of modelType.properties) {
-                if (property.restApiName === discriminator.propertyName) {
-                    modelType.discriminatorValue = property.type.value;
-                    discriminatorValues.push(modelType.discriminatorValue);
-                    discriminatorTcgcType = getClientType(context, property.type);
-                }
-            }
-            discriminatedSubtypes.push(modelType);
-        }
-        const discriminatorInfo = {
-            description: discriminatorValues.length > 0
-                ? `the discriminator possible values: ${discriminatorValues.join(", ")}`
-                : "discriminator property",
-            type: { type: "string", tcgcType: discriminatorTcgcType },
-            restApiName: discriminator.propertyName,
-            clientName: discriminator.propertyName,
-            name: discriminator.propertyName,
-            isPolymorphic: true,
-            isDiscriminator: true,
-            aliases,
-            discriminatedSubtypes
-        };
-        return discriminatorInfo;
-    }
-    return undefined;
-}
-function processModelProperties(context, newValue, model, usage) {
-    // need to do properties after insertion to avoid infinite recursion
-    const discriminatorInfo = handleDiscriminator(context, model, usage);
-    let hasDiscriminator = false;
-    for (const property of model.properties.values()) {
-        if (!isSchemaProperty(context.program, property)) {
-            continue;
-        }
-        if (isNeverType(property.type)) {
-            continue;
-        }
-        if (newValue.properties === undefined || newValue.properties === null) {
-            newValue.properties = [];
-        }
-        let newProperty = emitProperty(context, property, usage);
-        if (isDiscriminator(context, model, property.name)) {
-            hasDiscriminator = true;
-            newProperty = {
-                ...newProperty,
-                ...discriminatorInfo,
-                type: newProperty["type"],
-                tcgcType: getClientType(context, property)
-            };
-        }
-        newValue.properties.push(newProperty);
-    }
-    if (discriminatorInfo) {
-        if (!hasDiscriminator) {
-            newValue.properties.push({ ...discriminatorInfo });
-        }
-        // we don't need to add the discriminator info if it's an anonymous model
-        // because it's impossible to have a anonymous model as the polymorphic base in typespec
-        // the only possibility is the anonymous model is an alias for an union type which has already been taken care of in the combined types.
-        if (newValue.name) {
-            newValue.name = normalizeName(newValue.name, NameType.Interface);
-            discriminatorInfo === null || discriminatorInfo === void 0 ? void 0 : discriminatorInfo.aliases.push(`${newValue.name}`);
-            newValue.alias = `${newValue.name.replace(/Union$/g, "")}`;
-            newValue.name = `${newValue.name}`;
-            newValue.aliasType = discriminatorInfo === null || discriminatorInfo === void 0 ? void 0 : discriminatorInfo.aliases.join(" | ");
-            newValue.types = discriminatorInfo === null || discriminatorInfo === void 0 ? void 0 : discriminatorInfo.discriminatedSubtypes;
-            newValue.isPolymorphicBaseModel = true;
-            newValue.discriminator = discriminatorInfo.restApiName;
-        }
-    }
-}
-function isEmptyAnonymousModel(type) {
-    // object, {}, all will be treated as empty model
-    return (type.kind === "Model" &&
-        type.name === "" &&
-        type.properties.size === 0 &&
-        !type.baseModel &&
-        type.derivedModels.length === 0 &&
-        !type.indexer);
-}
-export function getType(context, type, options = {}) {
-    var _a, _b;
-    const modularMetatree = useContext("modularMetaTree");
-    // don't cache simple type(string, int, etc) since decorators may change the result
-    const enableCache = !isSimpleType(context.program, type);
-    const effectiveModel = !options.disableEffectiveModel &&
-        (type.kind === "Model" || type.kind === "Union")
-        ? getEffectiveSchemaType(context.program, type)
-        : type;
-    if (enableCache) {
-        const cached = typesMap.get(effectiveModel);
-        if (cached) {
-            return cached;
-        }
-    }
-    let newValue = { __raw: type };
-    if (isEmptyAnonymousModel(type)) {
-        // do not generate model for empty model, treat it as any
-        newValue = { type: "any" };
-    }
-    else {
-        newValue = emitType(context, type, options);
-    }
-    if (type.kind === "ModelProperty" || type.kind === "Scalar") {
-        newValue = applyEncoding(context.program, type, newValue);
-    }
-    if (isTypespecType(type)) {
-        newValue.tcgcType = getClientType(context, effectiveModel);
-        newValue.name = !newValue.tcgcType.isGeneratedName
-            ? normalizeModelName(context, newValue.tcgcType)
-            : newValue.name;
-        newValue.__raw = type;
-        modularMetatree.set(type, newValue);
-    }
-    if (enableCache) {
-        if (!options.disableEffectiveModel) {
-            if (newValue.__raw === undefined) {
-                newValue.__raw = type;
-            }
-            typesMap.set(effectiveModel, newValue);
-        }
-        if (type.kind === "Union") {
-            for (const t of type.variants.values()) {
-                if (t.type.kind === "Model") {
-                    processModelProperties(context, newValue, t.type, options.usage);
-                }
-            }
-        }
-        if (type.kind === "Model") {
-            // need to do properties after insertion to avoid infinite recursion
-            processModelProperties(context, newValue, type, options.usage);
-            if (newValue.type === "dict") {
-                newValue = { ...emitModel(context, type, options), ...newValue };
-                typesMap.set(effectiveModel, newValue);
-            }
-        }
-    }
-    else {
-        const { __raw, tcgcType, ...keyableValue } = newValue;
-        const key = JSON.stringify(keyableValue);
-        const value = simpleTypesMap.get(key);
-        if (value) {
-            newValue = value;
-        }
-        else {
-            simpleTypesMap.set(key, newValue);
-        }
-    }
-    if (type.kind === "Model" &&
-        newValue.tcgcType.additionalProperties &&
-        !((_a = context.rlcOptions) === null || _a === void 0 ? void 0 : _a.compatibilityMode)) {
-        reportDiagnostic(context.program, {
-            code: "compatible-additional-properties",
-            format: {
-                modelName: (_b = type === null || type === void 0 ? void 0 : type.name) !== null && _b !== void 0 ? _b : ""
-            },
-            target: type
-        });
-    }
-    typesMap.set(effectiveModel, newValue);
-    return newValue;
-}
-function isTypespecType(type) {
-    return type.kind !== "Credential" && type.kind !== "CredentialTypeUnion";
-}
-// To pass the yaml dump
-function getAddedOnVersion(p, t) {
-    var _a, _b;
-    return (_b = (_a = getAddedOnVersions(p, t)) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.value;
-}
-function emitParamBase(context, parameter) {
-    let optional;
-    let name;
-    let restApiName;
-    let description = "";
-    let addedOn;
-    let format;
-    const program = context.program;
-    if (parameter.kind === "ModelProperty") {
-        optional = parameter.optional;
-        name = normalizeName(getLibraryName(context, parameter), NameType.Parameter, true);
-        restApiName = getWireName(context, parameter);
-        description = getDocStr(program, parameter);
-        addedOn = getAddedOnVersion(program, parameter);
-        const newParameter = applyEncoding(program, parameter, parameter);
-        format = newParameter.format;
-    }
-    else {
-        optional = false;
-        name = "body";
-        restApiName = "body";
-    }
-    return {
-        optional,
-        description,
-        addedOn,
-        clientName: applyCasing(name, { casing: CASING }),
-        restApiName,
-        inOverload: false,
-        format,
-        tcgcType: getClientType(context, parameter)
-    };
-}
-function emitBodyParameter(context, httpOperation) {
-    var _a;
-    const params = httpOperation.parameters;
-    const body = params.body;
-    if (body.bodyKind === "single") {
-        const base = emitParamBase(context, (_a = body.parameter) !== null && _a !== void 0 ? _a : body.type);
-        let contentTypes = body.contentTypes;
-        if (contentTypes.length === 0) {
-            contentTypes = ["application/json"];
-        }
-        const type = getType(context, getBodyType(httpOperation), {
-            disableEffectiveModel: true,
-            usage: UsageFlags.Input
-        });
-        return {
-            contentTypes,
-            type,
-            location: "body",
-            ...base,
-            isBinaryPayload: isBinaryPayload(context, body.type, contentTypes),
-            optional: !isBodyRequired(httpOperation.parameters)
-        };
-    }
-    return undefined;
-}
-function emitParameter(context, parameter, implementation) {
-    var _a, _b;
-    if (parameter.type === "cookie") {
-        // TODO: support cookie parameters, https://github.com/Azure/autorest.typescript/issues/2898
-        reportDiagnostic(context.program, {
-            code: "parameter-type-not-supported",
-            format: {
-                paramType: parameter.type,
-                paramName: parameter.name
-            },
-            target: NoTarget
-        });
-        return undefined;
-    }
-    const base = emitParamBase(context, parameter.param);
-    let type = getType(context, parameter.param.type, {
-        usage: UsageFlags.Input
-    });
-    let clientDefaultValue = undefined;
-    if (parameter.name.toLowerCase() === "content-type" &&
-        type["type"] === "constant") {
-        /// We don't want constant types for content types, so we make sure if it's
-        /// a constant, we make it not constant
-        clientDefaultValue = type["value"];
-        type = {
-            ...type["valueType"],
-            tcgcType: base.tcgcType.kind === "constant"
-                ? base.tcgcType.valueType
-                : base.tcgcType
-        };
-    }
-    const paramMap = {
-        restApiName: parameter.name,
-        location: parameter.type,
-        type: base.format ? { ...type, format: base.format } : type,
-        implementation: implementation,
-        skipUrlEncoding: parameter.type === "endpointPath" ||
-            (parameter.type === "path" && parameter.allowReserved),
-        format: (_a = parameter.format) !== null && _a !== void 0 ? _a : base.format,
-        tcgcType: base.tcgcType
-    };
-    if (paramMap.type.type === "constant") {
-        clientDefaultValue = paramMap.type.value;
-    }
-    if (isApiVersion(context, parameter) &&
-        (paramMap.location === "query" || paramMap.location === "endpointPath")) {
-        const defaultApiVersion = getDefaultApiVersion(context, getServiceNamespace(context.program));
-        paramMap.implementation = implementation;
-        paramMap.in_docstring = false;
-        if (defaultApiVersion) {
-            clientDefaultValue = defaultApiVersion.value;
-        }
-        if (!clientDefaultValue) {
-            clientDefaultValue = getDefaultApiVersionString(context);
-        }
-        if (clientDefaultValue !== undefined) {
-            paramMap.optional = true;
-        }
-    }
-    if (clientDefaultValue === undefined &&
-        paramMap.location === "endpointPath" &&
-        ((_b = parameter.param.defaultValue) === null || _b === void 0 ? void 0 : _b.valueKind) === "StringValue") {
-        // For endpoint path params, treat the default value as a client default.
-        clientDefaultValue = parameter.param.defaultValue.value;
-    }
-    return { clientDefaultValue, ...base, ...paramMap };
-}
-function emitFlattenedParameter(bodyParameter, property) {
-    return {
-        checkClientInput: false,
-        clientDefaultValue: null,
-        clientName: property.clientName,
-        delimiter: null,
-        description: property.description,
-        implementation: "Method",
-        inDocstring: true,
-        inFlattenedBody: true,
-        inOverload: false,
-        inOverriden: false,
-        isApiVersion: bodyParameter["isApiVersion"],
-        location: "other",
-        optional: property["optional"],
-        restApiName: null,
-        skipUrlEncoding: false,
-        type: property["type"],
-        defaultToUnsetSentinel: true
-    };
-}
-function emitResponseHeaders(context, headers) {
-    const retval = [];
-    if (!headers) {
-        return retval;
-    }
-    for (const [key, value] of Object.entries(headers)) {
-        retval.push({
-            type: getType(context, value.type, { usage: UsageFlags.Output }),
-            restApiName: key
-        });
-    }
-    return retval;
-}
-function emitResponse(context, operation, response, innerResponse) {
-    var _a, _b, _c, _d, _e, _f;
-    let type = undefined;
-    if (((_a = innerResponse.body) === null || _a === void 0 ? void 0 : _a.type) &&
-        !isAzureCoreErrorType(context.program, (_b = innerResponse.body) === null || _b === void 0 ? void 0 : _b.type)) {
-        // temporary logic. It can be removed after compiler optimize the response
-        const candidate = [
-            "ResourceOkResponse",
-            "ResourceCreatedResponse",
-            "AcceptedResponse"
-        ];
-        const originType = innerResponse.body.type;
-        if (innerResponse.body.type.kind === "Model" &&
-            candidate.find((e) => e === originType.name)) {
-            const modelType = getEffectiveSchemaType(context.program, originType);
-            type = getType(context, modelType, { usage: UsageFlags.Output });
-        }
-        else if (isLroResponse()) {
-            const metadata = getLroMetadata(context.program, operation);
-            type =
-                (metadata === null || metadata === void 0 ? void 0 : metadata.finalResult) === "void" || (metadata === null || metadata === void 0 ? void 0 : metadata.finalResult) === undefined
-                    ? undefined
-                    : getType(context, metadata.finalResult);
-        }
-        else {
-            type = isVoidType(innerResponse.body.type)
-                ? undefined
-                : getType(context, innerResponse.body.type, {
-                    usage: UsageFlags.Output
-                });
-        }
-    }
-    const statusCodes = [];
-    if (response.statusCode === "*") {
-        statusCodes.push("default");
-    }
-    else {
-        statusCodes.push(parseInt(response.statusCode));
-    }
-    return {
-        headers: emitResponseHeaders(context, innerResponse.headers),
-        statusCodes: statusCodes !== null && statusCodes !== void 0 ? statusCodes : [],
-        addedOn: getAddedOnVersion(context.program, response.type),
-        discriminator: "basic",
-        type: type,
-        isBinaryPayload: ((_c = innerResponse.body) === null || _c === void 0 ? void 0 : _c.type)
-            ? isBinaryPayload(context, (_d = innerResponse.body) === null || _d === void 0 ? void 0 : _d.type, (_f = (_e = innerResponse.body) === null || _e === void 0 ? void 0 : _e.contentTypes[0]) !== null && _f !== void 0 ? _f : "application/json")
-            : false
-    };
-    function isLroResponse() {
-        var _a;
-        return (typeof response.statusCodes === "number" &&
-            ((_a = ["200", "201", "202"]) === null || _a === void 0 ? void 0 : _a.includes(`${response.statusCodes}`)) &&
-            !!getLroMetadata(context.program, operation));
-    }
-}
-function emitOperation(context, operation, operationGroupName, rlcModels, hierarchies) {
-    const isAzureFlavor = isAzurePackage(rlcModels);
-    const emittedOperation = emitBasicOperation(context, operation, operationGroupName, rlcModels, hierarchies);
-    // Skip to extract paging and lro information for non-branded clients.
-    if (!isAzureFlavor) {
-        return emittedOperation;
-    }
-    const lro = isLongRunningOperation(context.program, getHttpOperationWithCache(context, operation));
-    const pagingMetadata = getPagedResult(context.program, operation);
-    // Disable the paging feature if no itemsSegments is found.
-    const paging = pagingMetadata &&
-        pagingMetadata.itemsSegments &&
-        pagingMetadata.itemsSegments.length > 0;
-    if (pagingMetadata &&
-        (!pagingMetadata.itemsSegments || pagingMetadata.itemsSegments.length === 0)) {
-        reportDiagnostic(context.program, {
-            code: "no-paging-items-defined",
-            format: {
-                operationName: operation.name
-            },
-            target: operation
-        });
-    }
-    emitExtraInfoForOperation(emittedOperation);
-    return emittedOperation;
-    function emitExtraInfoForOperation(emittedOperation) {
-        if (lro) {
-            addLroInformation(context, operation, emittedOperation);
-        }
-        if (paging) {
-            addPagingInformation(context, operation, emittedOperation);
-        }
-        if (lro && paging) {
-            emittedOperation["discriminator"] = "lropaging";
-        }
-    }
-}
-function addLroInformation(context, operation, emittedOperation) {
-    emittedOperation["discriminator"] = "lro";
-    const metadata = getLroMetadata(context.program, operation);
-    emittedOperation["lroMetadata"] = {
-        finalResult: (metadata === null || metadata === void 0 ? void 0 : metadata.finalResult) === "void" || (metadata === null || metadata === void 0 ? void 0 : metadata.finalResult) === undefined
-            ? undefined
-            : getType(context, metadata.finalResult),
-        finalStateVia: getFinalStateVia(context, operation, metadata),
-        finalResultPath: metadata === null || metadata === void 0 ? void 0 : metadata.finalResultPath
-    };
-}
-function getFinalStateVia(context, operation, metadata) {
-    if (!metadata) {
-        return undefined;
-    }
-    switch (metadata.finalStateVia) {
-        case "azure-async-operation":
-        case "location":
-        case "operation-location":
-        case "original-uri":
-            return metadata.finalStateVia;
-        default:
-            reportDiagnostic(context.program, {
-                code: "un-supported-finalStateVia",
-                format: {
-                    finalStateVia: metadata.finalStateVia
-                },
-                target: operation
-            });
-            return undefined;
-    }
-}
-function addPagingInformation(context, operation, emittedOperation) {
-    emittedOperation["discriminator"] = "paging";
-    const pagedResult = getPagedResult(context.program, operation);
-    if (pagedResult === undefined) {
-        throw Error("Trying to add paging information, but not paging metadata for this operation");
-    }
-    emittedOperation["itemName"] = parseItemName(pagedResult);
-    emittedOperation["continuationTokenName"] = parseNextLinkName(pagedResult);
-}
-function emitBasicOperation(context, operation, operationGroupName, rlcModels, hierarchies) {
-    var _a, _b, _c, _d, _e;
-    // Set up parameters for operation
-    const parameters = [];
-    if (endpointPathParameters) {
-        for (const param of endpointPathParameters) {
-            parameters.push(param);
-        }
-    }
-    const httpOperation = getHttpOperationWithCache(context, operation);
-    const sourceOperation = operation.sourceOperation &&
-        !isTemplateDeclarationOrInstance(operation.sourceOperation)
-        ? operation.sourceOperation
-        : operation;
-    const sourceOperationGroupName = getOperationGroupName(context, sourceOperation);
-    const sourceOperationName = getOperationName(context, sourceOperation);
-    const sourceRoutePath = getHttpOperationWithCache(context, operation).path;
-    const rlcResponses = (_a = rlcModels.responses) === null || _a === void 0 ? void 0 : _a.filter((op) => {
-        return ((sourceOperationGroupName === "" ||
-            op.operationGroup === sourceOperationGroupName) &&
-            op.operationName === sourceOperationName &&
-            op.path === sourceRoutePath);
-    });
-    const namespaceHierarchies = ((_b = context.rlcOptions) === null || _b === void 0 ? void 0 : _b.hierarchyClient) === true ? hierarchies : [];
-    if (namespaceHierarchies.length === 0 &&
-        ((_c = context.rlcOptions) === null || _c === void 0 ? void 0 : _c.hierarchyClient) === false &&
-        operationGroupName !== "") {
-        namespaceHierarchies.push(operationGroupName);
-    }
-    for (const param of httpOperation.parameters.parameters) {
-        if (isIgnoredHeaderParam(param)) {
-            continue;
-        }
-        const emittedParam = emitParameter(context, param, "Method");
-        if (emittedParam === undefined) {
-            continue;
-        }
-        if (isApiVersion(context, param)) {
-            emittedParam.isApiVersion = true;
-            methodApiVersionParam = emittedParam;
-        }
-        parameters.push(emittedParam);
-    }
-    // Set up responses for operation
-    const responses = [];
-    const exceptions = [];
-    const isOverload = isSharedRoute(context.program, operation);
-    for (const response of httpOperation.responses) {
-        for (const innerResponse of response.responses) {
-            const emittedResponse = emitResponse(context, operation, response, innerResponse);
-            if (isErrorModel(context.program, response.type)) {
-                // * is valid status code in typespec but invalid for autorest.python
-                if (response.statusCode === "*") {
-                    exceptions.push(emittedResponse);
-                }
-            }
-            else {
-                responses.push(emittedResponse);
-            }
-        }
-    }
-    let bodyParameter;
-    if (httpOperation.parameters.body === undefined ||
-        isVoidType(httpOperation.parameters.body.type)) {
-        bodyParameter = undefined;
-    }
-    else {
-        bodyParameter = emitBodyParameter(context, httpOperation);
-        // Flatten the body parameter if it is an anonymous model
-        const originalBodyType = httpOperation.parameters.body.type;
-        if (bodyParameter.type.type === "model" &&
-            originalBodyType.kind === "Model" &&
-            originalBodyType.name === "" &&
-            [...originalBodyType.properties.keys()].every((k) => {
-                var _a;
-                return operation.parameters.properties.has(k) &&
-                    (operation.parameters.properties.get(k) ===
-                        originalBodyType.properties.get(k) ||
-                        operation.parameters.properties.get(k) ===
-                            ((_a = originalBodyType.properties.get(k)) === null || _a === void 0 ? void 0 : _a.sourceProperty));
-            })) {
-            for (const param of bodyParameter.type.properties) {
-                param.implementation = "Method";
-                param.location = (_d = param.location) !== null && _d !== void 0 ? _d : "body";
-                parameters.push(param);
-            }
-            bodyParameter = undefined;
-        }
-        else if (bodyParameter.type.type === "model" &&
-            bodyParameter.type.base === "json") {
-            bodyParameter["propertyToParameterName"] = {};
-            if (!isOverload) {
-                bodyParameter.defaultToUnsetSentinel = true;
-            }
-            for (const property of bodyParameter.type.properties) {
-                bodyParameter["propertyToParameterName"][property["restApiName"]] =
-                    property["clientName"];
-                parameters.push(emitFlattenedParameter(bodyParameter, property));
-            }
-        }
-    }
-    const name = applyCasing(getLibraryName(context, operation), {
-        casing: CASING
-    });
-    /** handle name collision between operation name and parameter signature */
-    if (bodyParameter) {
-        bodyParameter.clientName =
-            bodyParameter.clientName === name
-                ? bodyParameter.clientName + "Parameter"
-                : bodyParameter.clientName;
-    }
-    parameters
-        .filter((param) => {
-        return param.clientName === name && !param.isReadOnly && param.required;
-    })
-        .forEach((param) => {
-        param.clientName = param.clientName + "Parameter";
-    });
-    return {
-        name,
-        description: getDocStr(context.program, operation),
-        summary: (_e = getSummary(context.program, operation)) !== null && _e !== void 0 ? _e : "",
-        url: httpOperation.path,
-        method: httpOperation.verb.toUpperCase(),
-        parameters: parameters,
-        bodyParameter: bodyParameter,
-        responses: responses !== null && responses !== void 0 ? responses : [],
-        exceptions: exceptions !== null && exceptions !== void 0 ? exceptions : [],
-        groupName: operationGroupName,
-        addedOn: getAddedOnVersion(context.program, operation),
-        discriminator: "basic",
-        isOverload,
-        overloads: [],
-        apiVersions: [getAddedOnVersion(context.program, operation)],
-        rlcResponse: rlcResponses === null || rlcResponses === void 0 ? void 0 : rlcResponses[0],
-        namespaceHierarchies
-    };
-}
-function isReadOnly(program, type) {
-    // https://microsoft.github.io/typespec/standard-library/http/operations#automatic-visibility
-    // Only "read" should be readOnly
-    const visibility = getVisibility(program, type);
-    if (visibility) {
-        return visibility.includes("read") && visibility.length === 1;
-    }
-    else {
-        return false;
-    }
-}
-function emitProperty(context, property, usage) {
-    var _a, _b, _c;
-    const newProperty = applyEncoding(context.program, property, property);
-    let clientDefaultValue = undefined;
-    const propertyDefaultKind = (_a = property.default) === null || _a === void 0 ? void 0 : _a.kind;
-    if (property.default &&
-        (propertyDefaultKind === "Number" ||
-            propertyDefaultKind === "String" ||
-            propertyDefaultKind === "Boolean")) {
-        clientDefaultValue = property.default.value;
-    }
-    if (propertyDefaultKind === "EnumMember") {
-        clientDefaultValue = (_b = property.default.value) !== null && _b !== void 0 ? _b : property.default.name;
-    }
-    // const [clientName, jsonName] = getPropertyNames(context, property);
-    const clientName = getLibraryName(context, property);
-    const jsonName = getWireName(context, property);
-    if (property.model) {
-        getType(context, property.model, { usage });
-    }
-    const type = getType(context, property.type, { usage });
-    return {
-        clientName: ((_c = context.rlcOptions) === null || _c === void 0 ? void 0 : _c.ignorePropertyNameNormalize)
-            ? clientName
-            : normalizeName(clientName, NameType.Property),
-        restApiName: jsonName,
-        type: newProperty.format ? { ...type, format: newProperty.format } : type,
-        optional: property.optional,
-        description: getDocStr(context.program, property),
-        addedOn: getAddedOnVersion(context.program, property),
-        readonly: isReadOnly(context.program, property),
-        clientDefaultValue: clientDefaultValue,
-        format: newProperty.format
-    };
-}
-function getName(program, type) {
-    const friendlyName = getFriendlyName(program, type);
-    if (friendlyName) {
-        return friendlyName;
-    }
-    else {
-        if (type.templateMapper &&
-            type.templateMapper.args &&
-            type.name !== "" &&
-            type.templateMapper.args.length > 0) {
-            return (type.name +
-                type.templateMapper.args.filter((it) => isType(it))
-                    .map((it) => (it.kind === "Model" ? it.name : ""))
-                    .join(""));
-        }
-        else {
-            return type.name;
-        }
-    }
-}
-export function emitModel(context, type, options = {}) {
-    var _a, _b;
-    // Now we know it's a defined model
-    const properties = [];
-    let baseModel = undefined;
-    if (type.baseModel) {
-        baseModel = getType(context, type.baseModel, options);
-    }
-    const effectiveName = !options.disableEffectiveModel
-        ? getEffectiveSchemaType(context.program, type).name
-        : undefined;
-    const overridedModelName = normalizeName((_a = getLibraryName(context, type)) !== null && _a !== void 0 ? _a : getFriendlyName(context.program, type), NameType.Interface, true);
-    const fullNamespaceName = getModelNamespaceName(context, type.namespace)
-        .map((nsName) => {
-        return normalizeName(nsName, NameType.Interface);
-    })
-        .join("") +
-        (effectiveName ? effectiveName : getName(context.program, type));
-    let modelName = overridedModelName !== type.name
-        ? overridedModelName
-        : ((_b = context.rlcOptions) === null || _b === void 0 ? void 0 : _b.enableModelNamespace)
-            ? fullNamespaceName
-            : effectiveName
-                ? effectiveName
-                : getName(context.program, type);
-    if (!overridedModelName &&
-        type.templateMapper &&
-        type.templateMapper.args &&
-        type.templateMapper.args.length > 0 &&
-        getPagedResult(context.program, type)) {
-        modelName =
-            type.templateMapper.args.filter((it) => isType(it))
-                .map((it) => {
-                switch (it.kind) {
-                    case "Model":
-                        return it.name;
-                    case "String":
-                        return it.value;
-                    default:
-                        return "";
-                }
-            })
-                .join("") + "List";
-    }
-    const page = extractPagedMetadataNested(context.program, type);
-    const isPaging = page && page.itemsSegments && page.itemsSegments.length > 0;
-    return {
-        type: "model",
-        name: `${isPaging ? "_" : ""}${modelName}`,
-        description: getDocStr(context.program, type),
-        parents: baseModel ? [baseModel] : [],
-        discriminatedSubtypes: [],
-        properties: properties,
-        addedOn: getAddedOnVersion(context.program, type),
-        snakeCaseName: modelName
-            ? applyCasing(modelName, { casing: CASING })
-            : modelName,
-        base: modelName === "" ? "json" : "dpg",
-        coreTypeInfo: buildCoreTypeInfo(context.program, type),
-        usage: options.usage
-    };
-}
-function intOrFloat(value) {
-    return value.toString().indexOf(".") === -1 ? "integer" : "float";
-}
-function enumName(name) {
-    return name;
-}
-function emitEnum(context, type) {
-    var _a;
-    const program = context.program;
-    const enumValues = [];
-    for (const m of type.members.values()) {
-        enumValues.push({
-            name: enumName(m.name),
-            value: (_a = m.value) !== null && _a !== void 0 ? _a : m.name,
-            description: getDocStr(program, m)
-        });
-    }
-    if (enumValues.length === 0) {
-        throw new Error(`Expecting enum values but got none`);
-    }
-    const name = normalizeName(getLibraryName(context, type) ? getLibraryName(context, type) : type.name, NameType.Interface);
-    return {
-        type: "enum",
-        name,
-        description: getDocStr(program, type) === ""
-            ? `Type of ${name}`
-            : getDocStr(program, type),
-        valueType: { type: enumMemberType(type.members.values().next().value) },
-        values: enumValues,
-        isFixed: true,
-        coreTypeInfo: buildCoreTypeInfo(program, type)
-    };
-}
-function enumMemberType(member) {
-    if (typeof member.value === "number") {
-        return "number";
-    }
-    return "string";
-}
-function constantType(value, valueType) {
-    return { type: "constant", value: value, valueType: { type: valueType } };
-}
-function emitCredential(auth) {
-    let credential_type = {};
-    if (auth.type === "oauth2") {
-        credential_type = {
-            type: "OAuth2",
-            policy: {
-                type: "BearerTokenCredentialPolicy",
-                credentialScopes: []
-            }
-        };
-        for (const flow of auth.flows) {
-            for (const scope of flow.scopes) {
-                credential_type.policy.credentialScopes.push(scope.value);
-            }
-            credential_type.policy.credentialScopes.push();
-        }
-    }
-    else if (auth.type === "apiKey") {
-        credential_type = {
-            type: "Key",
-            policy: {
-                type: "AzureKeyCredentialPolicy",
-                key: auth.name
-            }
-        };
-    }
-    else if (auth.type === "http") {
-        credential_type = {
-            type: "Key",
-            policy: {
-                type: "AzureKeyCredentialPolicy",
-                key: "Authorization"
-            }
-        };
-    }
-    return credential_type;
-}
-function emitCredentialUnion(cred_types) {
-    const result = {};
-    // Export as CombinedType, which is already a Union Type in autorest codegen
-    result.type = "combined";
-    result.types = [];
-    for (const cred_type of cred_types.types) {
-        result.types.push(emitCredential(cred_type.scheme));
-    }
-    return result;
-}
-function emitStdScalar(program, scalar) {
-    var _a, _b, _c;
-    const newScalar = applyEncoding(program, scalar, scalar);
-    switch (scalar.name) {
-        case "bytes":
-            return { type: "byte-array", format: newScalar.format };
-        case "int8":
-        case "int16":
-        case "int32":
-        case "int64":
-        case "safeint":
-        case "uint8":
-        case "uint16":
-        case "uint32":
-        case "uint64":
-        case "integer":
-            return { type: "integer" };
-        case "float32":
-        case "float64":
-        case "float":
-            return { type: "float" };
-        case "url":
-        case "string":
-            return { type: "string" };
-        case "boolean":
-            return { type: "boolean" };
-        case "plainDate":
-            return { type: "string", format: (_a = newScalar.format) !== null && _a !== void 0 ? _a : "date" };
-        case "utcDateTime":
-            return { type: "datetime", format: newScalar.format };
-        case "plainTime":
-            return { type: "string", format: (_b = newScalar.format) !== null && _b !== void 0 ? _b : "time" };
-        case "offsetDateTime":
-            return { type: "string" };
-        case "duration":
-            return { type: "duration", format: newScalar.format };
-        case "numeric":
-            return {}; // Waiting on design for more precise type https://github.com/microsoft/cadl/issues/1260
-        case "decimal":
-        case "decimal128":
-            reportDiagnostic(program, {
-                code: "decimal-to-number",
-                format: {
-                    propertyName: (_c = newScalar === null || newScalar === void 0 ? void 0 : newScalar.name) !== null && _c !== void 0 ? _c : ""
-                },
-                target: NoTarget
-            });
-            return { type: "integer", format: newScalar.format };
-        default:
-            return {};
-    }
-}
-function applyEncoding(program, typespecType, target = {}) {
-    const encodeData = getEncode(program, typespecType);
-    if (encodeData) {
-        const newTarget = { ...target };
-        const newType = emitScalar(program, encodeData.type);
-        // newTarget["type"] = newType["type"];
-        // If the target already has a format it takes priority. (e.g. int32)
-        newTarget["format"] = mergeFormatAndEncoding(newTarget.format, encodeData.encoding, newType["format"]);
-        return newTarget;
-    }
-    return target;
-}
-function mergeFormatAndEncoding(format, encoding, encodeAsFormat) {
-    var _a, _b;
-    switch (format) {
-        case undefined:
-            return (_a = encodeAsFormat !== null && encodeAsFormat !== void 0 ? encodeAsFormat : encoding) !== null && _a !== void 0 ? _a : format;
-        case "date-time":
-            return encoding;
-        case "duration":
-        default:
-            return (_b = encodeAsFormat !== null && encodeAsFormat !== void 0 ? encodeAsFormat : encoding) !== null && _b !== void 0 ? _b : format;
-    }
-}
-function applyIntrinsicDecorators(program, type, result) {
-    let newResult = { ...result };
-    const docStr = getDoc(program, type);
-    const isString = isStringType(program, getPropertyType(type));
-    const isNumeric = isNumericType(program, getPropertyType(type));
-    if (!result.description && docStr) {
-        newResult.description = docStr;
-    }
-    newResult = applyEncoding(program, type, newResult);
-    const pattern = getPattern(program, type);
-    if (isString && !result.pattern && pattern) {
-        newResult.pattern = pattern;
-    }
-    const minLength = getMinLength(program, type);
-    if (isString && !result.minLength && minLength !== undefined) {
-        newResult.minLength = minLength;
-    }
-    const maxLength = getMaxLength(program, type);
-    if (isString && !result.maxLength && maxLength !== undefined) {
-        newResult.maxLength = maxLength;
-    }
-    const minValue = getMinValue(program, type);
-    if (isNumeric && !result.minimum && minValue !== undefined) {
-        newResult.minimum = minValue;
-    }
-    const maxValue = getMaxValue(program, type);
-    if (isNumeric && !result.maximum && maxValue !== undefined) {
-        newResult.maximum = maxValue;
-    }
-    const minItems = getMinItems(program, type);
-    if (!result.minItems && minItems !== undefined) {
-        newResult.minItems = minItems;
-    }
-    const maxItems = getMaxItems(program, type);
-    if (!result.maxItems && maxItems !== undefined) {
-        newResult.maxItems = maxItems;
-    }
-    return newResult;
-}
-function emitScalar(program, scalar) {
-    let result = {};
-    const isStd = program.checker.isStdType(scalar);
-    if (isStd) {
-        result = emitStdScalar(program, scalar);
-    }
-    else if (scalar.baseScalar) {
-        result = emitScalar(program, scalar.baseScalar);
-    }
-    return applyIntrinsicDecorators(program, scalar, result);
-}
-function emitListOrDict(context, type, usage) {
-    if (type.indexer !== undefined) {
-        if (!isNeverType(type.indexer.key)) {
-            const name = type.indexer.key.name;
-            if (name === "string") {
-                return {
-                    type: "dict",
-                    name: type.name,
-                    elementType: getType(context, type.indexer.value, { usage })
-                };
-            }
-            else if (name === "integer") {
-                return {
-                    type: "list",
-                    elementType: getType(context, type.indexer.value, { usage })
-                };
-            }
-        }
-    }
-    return undefined;
-}
-function mapTypeSpecType(context, type, usage) {
-    switch (type.kind) {
-        case "Number":
-            return constantType(type.value, intOrFloat(type.value));
-        case "String":
-            return constantType(type.value, "string");
-        case "Boolean":
-            return constantType(type.value, "boolean");
-        case "Model":
-            return emitListOrDict(context, type, usage);
-    }
-}
-function emitUnion(context, type, usage) {
-    var _a, _b, _c;
-    let sdkType = getSdkUnion(context, type);
-    const isNull = sdkType.kind === "nullable";
-    if (sdkType.kind === "nullable") {
-        sdkType = sdkType.type;
-    }
-    const nonNullOptions = getNonNullOptions(type);
-    if (sdkType === undefined) {
-        throw Error("Should not have an empty union");
-    }
-    if (sdkType.kind === "union") {
-        const unionName = getLibraryName(context, type)
-            ? getLibraryName(context, type)
-            : type.name;
-        const discriminatorPropertyName = (_a = getDiscriminator(context.program, type)) === null || _a === void 0 ? void 0 : _a.propertyName;
-        const variantTypes = sdkType.variantTypes.map((x) => {
-            const valueType = getType(context, x.__raw, { usage });
-            if (valueType.properties && discriminatorPropertyName) {
-                valueType.discriminatorValue = valueType.properties.filter((p) => p.clientName === discriminatorPropertyName)[0].type.value;
-            }
-            return valueType;
-        });
-        const unionTypeName = unionName
-            ? normalizeName(unionName, NameType.Interface)
-            : undefined;
-        return {
-            nullable: isNull,
-            name: unionTypeName,
-            description: `Type of ${unionTypeName}`,
-            internal: true,
-            type: "combined",
-            types: variantTypes,
-            xmlMetadata: {},
-            usage,
-            discriminator: discriminatorPropertyName,
-            alias: unionName === "" || unionName === undefined ? undefined : unionName,
-            aliasType: unionName === "" || unionName === undefined
-                ? undefined
-                : variantTypes.map((x) => getTypeName(x).name).join(" | "),
-            tcgcType: sdkType
-        };
-    }
-    else if (sdkType.kind === "enum") {
-        let typeName = getLibraryName(context, type)
-            ? getLibraryName(context, type)
-            : sdkType.isGeneratedName
-                ? type.name
-                : sdkType.name;
-        typeName = typeName
-            ? normalizeName(typeName, NameType.Interface)
-            : undefined;
-        return {
-            name: typeName,
-            nullable: isNull,
-            description: sdkType.doc || `Type of ${typeName}`,
-            internal: true,
-            type: sdkType.kind,
-            valueType: emitSimpleType(sdkType.valueType),
-            values: sdkType.values.map((x) => emitEnumMember(context, x)),
-            isFixed: sdkType.isFixed,
-            isNonExhaustive: (_c = (_b = context.rlcOptions) === null || _b === void 0 ? void 0 : _b.experimentalExtensibleEnums) !== null && _c !== void 0 ? _c : false,
-            xmlMetadata: {},
-            usage
-        };
-    }
-    else if (nonNullOptions.length === 1 && nonNullOptions[0]) {
-        return {
-            ...emitType(context, nonNullOptions[0], { usage }),
-            nullable: isNull
-        };
-    }
-    else {
-        return {
-            ...emitType(context, sdkType.__raw, { usage }),
-            nullable: isNull
-        };
-    }
-}
-function getNonNullOptions(type) {
-    return [...type.variants.values()]
-        .map((x) => x.type)
-        .filter((t) => !isNullType(t));
-}
-function emitEnumMember(context, member) {
-    var _a;
-    const value = (_a = member.value) !== null && _a !== void 0 ? _a : member.name;
-    return {
-        type: "constant",
-        valueType: {
-            type: enumMemberType(member)
-        },
-        value,
-        name: member.name ? enumName(member.name) : undefined,
-        description: getDoc(context.program, member),
-        isConstant: true
-    };
-}
-function emitSimpleType(type) {
-    return {
-        nullable: isNullType(type.__raw),
-        type: type.kind === "string" ? "string" : "number", // TODO: handle other types
-        doc: "",
-        apiVersions: [],
-        sdkDefaultValue: undefined,
-        format: undefined
-    };
-}
-function emitType(context, type, options = {}) {
-    if (type.kind === "Credential") {
-        return emitCredential(type.scheme);
-    }
-    if (type.kind === "CredentialTypeUnion") {
-        return emitCredentialUnion(type);
-    }
-    const builtinType = mapTypeSpecType(context, type, options.usage);
-    if (builtinType !== undefined) {
-        // add in description elements for types derived from primitive types (SecureString, etc.)
-        const doc = getDoc(context.program, type);
-        if (doc) {
-            builtinType.description = doc;
-        }
-        return builtinType;
-    }
-    switch (type.kind) {
-        case "Intrinsic":
-            return { type: type.name };
-        case "Model":
-            return emitModel(context, type, options);
-        case "Scalar":
-            return emitScalar(context.program, type);
-        case "Union":
-            return emitUnion(context, type, options.usage);
-        case "UnionVariant":
-            return emitType(context, type.type, options);
-        case "Enum":
-            return emitEnum(context, type);
-        case "EnumMember":
-            return emitEnumMember(context, type);
-        case "ModelProperty":
-            return emitType(context, type.type, options);
-        default:
-            throw Error(`Not supported ${type.kind}`);
-    }
-}
-function emitOperationGroups(context, client, rlcModels) {
-    var _a, _b, _c, _d, _e, _f, _g;
-    const operationGroups = [];
-    const groupMapping = new Map();
-    const clientOperations = [];
-    for (const operation of listOperationsInOperationGroup(context, client)) {
-        clientOperations.push(emitOperation(context, operation, "", rlcModels, []));
-    }
-    if (clientOperations.length > 0) {
-        addHierarchyOperationGroup(clientOperations, groupMapping);
-    }
-    for (const operationGroup of listOperationGroups(context, client, true)) {
-        const operations = [];
-        const overrideName = getLibraryName(context, operationGroup.type);
-        const name = ((_a = context.rlcOptions) === null || _a === void 0 ? void 0 : _a.hierarchyClient) ||
-            ((_b = context.rlcOptions) === null || _b === void 0 ? void 0 : _b.enableOperationGroup)
-            ? (overrideName !== null && overrideName !== void 0 ? overrideName : operationGroup.type.name)
-            : "";
-        const hierarchies = ((_c = context.rlcOptions) === null || _c === void 0 ? void 0 : _c.hierarchyClient) ||
-            ((_d = context.rlcOptions) === null || _d === void 0 ? void 0 : _d.enableOperationGroup)
-            ? operationGroup.groupPath.split(".")
-            : [];
-        if ((_e = hierarchies[0]) === null || _e === void 0 ? void 0 : _e.endsWith("Client")) {
-            hierarchies.shift();
-        }
-        for (const operation of listOperationsInOperationGroup(context, operationGroup)) {
-            operations.push(emitOperation(context, operation, name, rlcModels, hierarchies));
-        }
-        if (operations.length > 0) {
-            addHierarchyOperationGroup(operations, groupMapping);
-        }
-    }
-    groupMapping.forEach((value) => {
-        operationGroups.push(value);
-    });
-    if (((_f = context.rlcOptions) === null || _f === void 0 ? void 0 : _f.hierarchyClient) === false &&
-        ((_g = context.rlcOptions) === null || _g === void 0 ? void 0 : _g.enableOperationGroup)) {
-        appendOperationGroupPrefix(operationGroups);
-    }
-    return operationGroups;
-}
-function addHierarchyOperationGroup(operations, groupMapping) {
-    if (operations.length > 0) {
-        operations.forEach((op) => {
-            var _a;
-            const groupName = (_a = op.namespaceHierarchies.join("")) !== null && _a !== void 0 ? _a : "";
-            if (!groupMapping.has(groupName)) {
-                groupMapping.set(groupName, {
-                    className: groupName,
-                    propertyName: groupName,
-                    operations: [op],
-                    namespaceHierarchies: op.namespaceHierarchies
-                });
-            }
-            else {
-                groupMapping.get(groupName).operations.push(op);
-            }
-        });
-        return [...groupMapping.values()];
-    }
-    return [];
-}
-function appendOperationGroupPrefix(operationGroups) {
-    if (operationGroups.length < 2) {
-        return;
-    }
-    // Append operation group prefix
-    operationGroups.forEach((g) => g.operations.forEach((op) => {
-        op.oriName = op.name;
-        op.name = `${g.propertyName}_${op.name}`;
-    }));
-}
-function getServerHelper(program, namespace) {
-    const servers = getServers(program, namespace);
-    if (servers === undefined) {
-        return undefined;
-    }
-    return servers[0];
-}
-function emitServerParams(context, namespace) {
-    const server = getServerHelper(context.program, namespace);
-    if (server === undefined || server.parameters.size === 0) {
-        return [
-            {
-                optional: false,
-                description: "Service host",
-                clientName: "endpointParam",
-                clientDefaultValue: null,
-                restApiName: "endpoint",
-                location: "endpointPath",
-                type: { type: "string" },
-                implementation: "Client",
-                inOverload: false
-            }
-        ];
-    }
-    if (server.parameters) {
-        const params = [];
-        for (const param of server.parameters.values()) {
-            const serverParameter = {
-                type: "endpointPath",
-                name: param.name,
-                param: param
-            };
-            const emittedParameter = emitParameter(context, serverParameter, "Client");
-            if (emittedParameter === undefined) {
-                continue;
-            }
-            endpointPathParameters.push(emittedParameter);
-            if (isApiVersion(context, serverParameter)) {
-                emittedParameter.isApiVersion = true;
-                serverApiVersionParam = emittedParameter;
-                emittedParameter.isApiVersion = true;
-            }
-            params.push(emittedParameter);
-        }
-        return params;
-    }
-    else {
-        return [
-            {
-                optional: false,
-                description: "Service host",
-                clientName: "endpointParam",
-                clientDefaultValue: server.url,
-                restApiName: "endpoint",
-                location: "path",
-                type: { type: "string" },
-                implementation: "Client",
-                inOverload: false
-            }
-        ];
-    }
-}
-function emitCredentialParam(context, namespace) {
-    var _a;
-    const auth = getAuthentication(context.program, namespace);
-    if (auth) {
-        const credential_types = [];
-        for (const scheme of getSupportedHttpAuth(context.program, auth)) {
-            const type = {
-                kind: "Credential",
-                scheme: scheme
-            };
-            credential_types.push(type);
-        }
-        if (credential_types.length > 0 &&
-            ((_a = context.rlcOptions) === null || _a === void 0 ? void 0 : _a.addCredentials) !== false) {
-            let type;
-            if (credential_types.length === 1 && credential_types[0]) {
-                type = credential_types[0];
-            }
-            else {
-                type = {
-                    kind: "CredentialTypeUnion",
-                    types: credential_types
-                };
-            }
-            return {
-                type: getType(context, type, { usage: UsageFlags.Input }),
-                optional: false,
-                description: "Credential needed for the client to connect to Azure.",
-                clientName: "credential",
-                location: "other",
-                restApiName: "credential",
-                implementation: "Client",
-                skipUrlEncoding: true,
-                inOverload: false
-            };
-        }
-    }
-    return undefined;
-}
-function emitGlobalParameters(context, namespace) {
-    const clientParameters = emitServerParams(context, namespace);
-    const credentialParam = emitCredentialParam(context, namespace);
-    if (credentialParam) {
-        clientParameters.push(credentialParam);
-    }
-    return clientParameters;
-}
-function getMethodApiVersionParameter() {
-    if (methodApiVersionParam) {
-        return {
-            ...methodApiVersionParam,
-            isApiVersion: true
-        };
-    }
-}
-function emitClients(context, rlcModelsMap) {
-    var _a;
-    const program = context.program;
-    const clients = listClients(context);
-    const retval = [];
-    methodApiVersionParam = undefined;
-    for (const client of clients) {
-        const sdkPackageClient = context.sdkPackage.clients.find((p) => {
-            return p.name === client.name;
-        });
-        if (!sdkPackageClient) {
-            throw new Error(`Client ${client.name} not found in the SDK package`);
-        }
-        const clientName = client.name.replace("Client", "");
-        const server = getServerHelper(program, client.service);
-        const rlcModels = rlcModelsMap.get(client.service.name);
-        if (!rlcModels) {
-            continue;
-        }
-        const emittedClient = {
-            name: (_a = clientName.split(".").at(-1)) !== null && _a !== void 0 ? _a : "",
-            description: getDocStr(program, client.type),
-            parameters: emitGlobalParameters(context, client.service),
-            operationGroups: emitOperationGroups(context, client, rlcModels),
-            tcgcClient: sdkPackageClient,
-            url: server ? server.url : "",
-            apiVersions: [],
-            rlcClientName: `${client.name.replace("Client", "")}Context`,
-            subfolder: "",
-            rlcHelperDetails: rlcModels && rlcModels.helperDetails ? rlcModels.helperDetails : {}
-        };
-        const methodApiVersionParam = getMethodApiVersionParameter();
-        if (methodApiVersionParam &&
-            !serverApiVersionParam &&
-            context.hasApiVersionInClient) {
-            // prompt method-level api version to client level only when there is no client one defined
-            emittedClient.parameters.push(methodApiVersionParam);
-            // if we have client level api version, we need to remove it from all operations
-            emittedClient.operationGroups.map((opGroup) => {
-                opGroup.operations.map((op) => {
-                    op.parameters = op.parameters.filter((param) => {
-                        return !param.isApiVersion;
-                    });
-                    return op;
-                });
-                return opGroup;
-            });
-        }
-        retval.push(emittedClient);
-    }
-    return retval;
-}
-function getServiceNamespace(program) {
-    return listServices(program)[0].type;
-}
-function getNamespace(context, clientName) {
-    // We get client namespaces from the client name. If there's a dot, we add that to the namespace
-    const submodule = clientName.split(".").slice(0, -1).join(".").toLowerCase();
-    if (!submodule) {
-        return getClientNamespaceString(context).toLowerCase();
-    }
-    return submodule;
-}
-function getNamespaces(context) {
-    const namespaces = new Set();
-    for (const client of listClients(context)) {
-        namespaces.add(getNamespace(context, client.name));
-    }
-    return namespaces;
-}
-export function emitCodeModel(dpgContext, rlcModelsMap, modularSourcesRoot, project, options = { casing: "snake" }) {
-    var _a, _b, _c, _d, _e, _f;
-    CASING = (_a = options.casing) !== null && _a !== void 0 ? _a : CASING;
-    const clientNamespaceString = (_b = getClientNamespaceString(dpgContext)) === null || _b === void 0 ? void 0 : _b.toLowerCase();
-    // Get types
-    const codeModel = {
-        options: (_c = dpgContext.rlcOptions) !== null && _c !== void 0 ? _c : {},
-        modularOptions: {
-            sourceRoot: modularSourcesRoot,
-            compatibilityMode: !!((_d = dpgContext.rlcOptions) === null || _d === void 0 ? void 0 : _d.compatibilityMode),
-            experimentalExtensibleEnums: !!((_e = dpgContext.rlcOptions) === null || _e === void 0 ? void 0 : _e.experimentalExtensibleEnums)
-        },
-        namespace: clientNamespaceString,
-        clients: [],
-        types: [],
-        project,
-        runtimeImports: buildRuntimeImports((_f = dpgContext.rlcOptions) === null || _f === void 0 ? void 0 : _f.flavor)
-    };
-    typesMap.clear();
-    simpleTypesMap.clear();
-    const allModels = getAllModels(dpgContext);
-    for (const model of allModels) {
-        getType(dpgContext, model.__raw, { usage: model.usage });
-    }
-    for (const namespace of getNamespaces(dpgContext)) {
-        if (namespace === clientNamespaceString) {
-            codeModel.clients = emitClients(dpgContext, rlcModelsMap);
-            codeModel.clients.length > 1 &&
-                codeModel.clients.map((client) => {
-                    client["subfolder"] = normalizeName(client.name.replace("Client", ""), NameType.File);
-                });
-        }
-    }
-    codeModel["types"] = [
-        { type: "string" },
-        ...typesMap.values(),
-        ...simpleTypesMap.values()
-    ];
-    return codeModel;
-}
-//# sourceMappingURL=buildCodeModel.js.map