@azure-tools/typespec-ts 0.11.0 → 0.12.0

package/dist/src/modular/buildCodeModel.js

@@ -0,0 +1,1110 @@
+import { getPagedResult, isFixed } from "@azure-tools/typespec-azure-core";
+import { getDoc, getFriendlyName, getMaxLength, getMaxValue, getMinLength, getMinValue, getPattern, getSummary, getVisibility, ignoreDiagnostics, isErrorModel, isNeverType, getEffectiveModelType, getDiscriminator, isKey, isStringType, getPropertyType, isNumericType, getFormat, getMinItems, getMaxItems, listServices, isNullType, SyntaxKind, getProjectedName } from "@typespec/compiler";
+import { getAuthentication, getHeaderFieldName, getHttpOperation, getPathParamName, getQueryParamName, getServers, isStatusCode, isHeader } from "@typespec/http";
+import { getAddedOnVersions } from "@typespec/versioning";
+import { listClients, listOperationGroups, listOperationsInOperationGroup, isApiVersion, getDefaultApiVersion, getClientNamespaceString, createSdkContext } from "@azure-tools/typespec-client-generator-core";
+import { getResourceOperation } from "@typespec/rest";
+import { transformRLCOptions } from "../transform/transfromRLCOptions.js";
+import { camelToSnakeCase, toCamelCase } from "../casingUtils.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 apiVersionParam = 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
+        ];
+        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 isLro(_program, operation) {
+    for (const decorator of operation.decorators) {
+        if (decorator.decorator.name === "$pollingOperation") {
+            return true;
+        }
+    }
+    return false;
+}
+function handleDiscriminator(program, type, model) {
+    const discriminator = getDiscriminator(program, type);
+    if (discriminator) {
+        let discriminatorProperty;
+        for (const childModel of type.derivedModels) {
+            const modelType = getType(program, childModel);
+            for (const property of modelType.properties) {
+                if (property.restApiName === discriminator.propertyName) {
+                    modelType.discriminatorValue = property.type.value;
+                    property.isDiscriminator = true;
+                    model.discriminatedSubtypes[property.type.value] = modelType;
+                    discriminatorProperty = property;
+                }
+            }
+        }
+        // it is not included in properties of cadl but needed by python codegen
+        if (discriminatorProperty) {
+            const discriminatorType = { ...discriminatorProperty.type };
+            discriminatorType.value = null;
+            const propertyCopy = {
+                ...discriminatorProperty,
+                isPolymorphic: true,
+                type: discriminatorType
+            };
+            propertyCopy.description = "";
+            model.properties.push(propertyCopy);
+        }
+    }
+}
+function getEffectiveSchemaType(program, type) {
+    function isSchemaProperty(property) {
+        const headerInfo = getHeaderFieldName(program, property);
+        const queryInfo = getQueryParamName(program, property);
+        const pathInfo = getPathParamName(program, property);
+        const statusCodeinfo = isStatusCode(program, property);
+        return !(headerInfo || queryInfo || pathInfo || statusCodeinfo);
+    }
+    const effective = getEffectiveModelType(program, type, isSchemaProperty);
+    if (effective.name) {
+        return effective;
+    }
+    return type;
+}
+function getType(program, type) {
+    // don't cache simple type(string, int, etc) since decorators may change the result
+    const enableCache = !isSimpleType(program, type);
+    const effectiveModel = type.kind === "Model" ? getEffectiveSchemaType(program, type) : type;
+    if (enableCache) {
+        const cached = typesMap.get(effectiveModel);
+        if (cached) {
+            return cached;
+        }
+    }
+    let newValue = emitType(program, type);
+    if (enableCache) {
+        typesMap.set(effectiveModel, newValue);
+        if (type.kind === "Model") {
+            // need to do properties after insertion to avoid infinite recursion
+            for (const property of type.properties.values()) {
+                if (isStatusCode(program, property) ||
+                    isNeverType(property.type) ||
+                    isHeader(program, property)) {
+                    continue;
+                }
+                newValue.properties.push(emitProperty(program, property));
+            }
+            // need to do discriminator outside `emitModel` to avoid infinite recursion
+            handleDiscriminator(program, type, newValue);
+        }
+    }
+    else {
+        const key = JSON.stringify(newValue);
+        const value = simpleTypesMap.get(key);
+        if (value) {
+            newValue = value;
+        }
+        else {
+            simpleTypesMap.set(key, newValue);
+        }
+    }
+    return newValue;
+}
+// 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(program, parameter) {
+    let optional;
+    let name;
+    let description = "";
+    let addedOn;
+    if (parameter.kind === "ModelProperty") {
+        optional = parameter.optional;
+        name = parameter.name;
+        description = getDocStr(program, parameter);
+        addedOn = getAddedOnVersion(program, parameter);
+    }
+    else {
+        optional = false;
+        name = "body";
+    }
+    return {
+        optional,
+        description,
+        addedOn,
+        clientName: applyCasing(name, { casing: CASING }),
+        inOverload: false
+    };
+}
+function getBodyType(program, route) {
+    var _a, _b, _c, _d;
+    let bodyModel = (_a = route.parameters.body) === null || _a === void 0 ? void 0 : _a.type;
+    if (bodyModel && bodyModel.kind === "Model" && route.operation) {
+        const resourceType = (_b = getResourceOperation(program, route.operation)) === null || _b === void 0 ? void 0 : _b.resourceType;
+        if (resourceType && route.responses && route.responses.length > 0) {
+            const resp = route.responses[0];
+            if (resp && resp.responses && resp.responses.length > 0) {
+                const responseBody = (_c = resp.responses[0]) === null || _c === void 0 ? void 0 : _c.body;
+                if (((_d = responseBody === null || responseBody === void 0 ? void 0 : responseBody.type) === null || _d === void 0 ? void 0 : _d.kind) === "Model") {
+                    const bodyTypeInResponse = getEffectiveSchemaType(program, responseBody.type);
+                    // response body type is reosurce type, and request body type (if templated) contains resource type
+                    if (bodyTypeInResponse === resourceType &&
+                        bodyModel.templateMapper &&
+                        bodyModel.templateMapper.args &&
+                        bodyModel.templateMapper.args.some((it) => {
+                            return it.kind === "Model" || it.kind === "Union"
+                                ? it === bodyTypeInResponse
+                                : false;
+                        })) {
+                        bodyModel = resourceType;
+                    }
+                }
+            }
+        }
+        if (resourceType && bodyModel.name === "") {
+            bodyModel = resourceType;
+        }
+    }
+    return bodyModel;
+}
+function emitBodyParameter(program, httpOperation) {
+    var _a, _b, _c, _d, _e;
+    const params = httpOperation.parameters;
+    const body = params.body;
+    const base = emitParamBase(program, (_a = body.parameter) !== null && _a !== void 0 ? _a : body.type);
+    let contentTypes = body.contentTypes;
+    if (contentTypes.length === 0) {
+        contentTypes = ["application/json"];
+    }
+    if (contentTypes.length !== 1) {
+        throw Error("Currently only one kind of content-type!");
+    }
+    const type = getType(program, getBodyType(program, httpOperation));
+    if (type.type === "model" && type.name === "") {
+        type.name = capitalize(httpOperation.operation.name) + "Request";
+    }
+    return {
+        contentTypes,
+        type,
+        restApiName: (_c = (_b = body.parameter) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : "body",
+        location: "body",
+        ...base,
+        defaultContentType: ((_e = (_d = body.parameter) === null || _d === void 0 ? void 0 : _d.default) !== null && _e !== void 0 ? _e : contentTypes.includes("application/json"))
+            ? "application/json"
+            : contentTypes[0]
+    };
+}
+function emitParameter(context, parameter, implementation) {
+    const base = emitParamBase(context.program, parameter.param);
+    let type = getType(context.program, parameter.param.type);
+    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"];
+    }
+    const paramMap = {
+        restApiName: parameter.name,
+        location: parameter.type,
+        type: type,
+        implementation: implementation,
+        skipUrlEncoding: parameter.type === "endpointPath"
+    };
+    if (paramMap.type.type === "constant") {
+        clientDefaultValue = paramMap.type.value;
+    }
+    if (isApiVersion(context, parameter)) {
+        const defaultApiVersion = getDefaultApiVersion(context, getServiceNamespace(context.program));
+        paramMap.type = defaultApiVersion
+            ? getConstantType(defaultApiVersion.value)
+            : { type: "string" };
+        paramMap.implementation = "Client";
+        paramMap.in_docstring = false;
+        if (defaultApiVersion) {
+            clientDefaultValue = defaultApiVersion.value;
+        }
+    }
+    return { clientDefaultValue, ...base, ...paramMap };
+}
+function emitContentTypeParameter(bodyParameter, inOverload, inOverriden) {
+    return {
+        checkClientInput: false,
+        clientDefaultValue: bodyParameter.defaultContentType,
+        clientName: "content_type",
+        delimiter: null,
+        description: `Body parameter Content-Type. Known values are: ${bodyParameter.contentTypes}.`,
+        implementation: "Method",
+        inDocstring: true,
+        inOverload: inOverload,
+        inOverriden: inOverriden,
+        location: "header",
+        optional: true,
+        restApiName: "Content-Type",
+        type: { type: "string" }
+    };
+}
+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 getConstantType(key) {
+    const cache = simpleTypesMap.get(key);
+    if (cache) {
+        return cache;
+    }
+    const type = {
+        apiVersions: [],
+        clientDefaultValue: null,
+        type: "constant",
+        value: key,
+        valueType: { type: "string" },
+        xmlMetadata: {}
+    };
+    simpleTypesMap.set(key, type);
+    return type;
+}
+function emitAcceptParameter(_program, inOverload, inOverriden) {
+    return {
+        checkClientInput: false,
+        clientDefaultValue: "application/json",
+        clientName: "accept",
+        delimiter: null,
+        description: "Accept header.",
+        explode: false,
+        groupedBy: null,
+        implementation: "Method",
+        inDocstring: true,
+        inOverload: inOverload,
+        inOverriden: inOverriden,
+        location: "header",
+        optional: false,
+        restApiName: "Accept",
+        skipUrlEncoding: false,
+        type: getConstantType("application/json")
+    };
+}
+function emitResponseHeaders(program, headers) {
+    const retval = [];
+    if (!headers) {
+        return retval;
+    }
+    for (const [key, value] of Object.entries(headers)) {
+        retval.push({
+            type: getType(program, value.type),
+            restApiName: key
+        });
+    }
+    return retval;
+}
+function isAzureCoreErrorType(t) {
+    var _a;
+    if ((t === null || t === void 0 ? void 0 : t.kind) !== "Model" ||
+        !["Error", "ErrorResponse", "InnerError"].includes(t.name))
+        return false;
+    const namespaces = ".Azure.Core.Foundations".split(".");
+    while (namespaces.length > 0 &&
+        ((t === null || t === void 0 ? void 0 : t.kind) === "Model" || (t === null || t === void 0 ? void 0 : t.kind) === "Namespace") &&
+        ((_a = t.namespace) === null || _a === void 0 ? void 0 : _a.name) === namespaces.pop()) {
+        t = t.namespace;
+    }
+    return namespaces.length == 0;
+}
+function emitResponse(program, response, innerResponse) {
+    var _a, _b;
+    let type = undefined;
+    if (((_a = innerResponse.body) === null || _a === void 0 ? void 0 : _a.type) &&
+        !isAzureCoreErrorType((_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(program, originType);
+            type = getType(program, modelType);
+        }
+        else {
+            type = getType(program, innerResponse.body.type);
+        }
+    }
+    const statusCodes = [];
+    if (response.statusCode === "*") {
+        statusCodes.push("default");
+    }
+    else {
+        statusCodes.push(parseInt(response.statusCode));
+    }
+    return {
+        headers: emitResponseHeaders(program, innerResponse.headers),
+        statusCodes: statusCodes !== null && statusCodes !== void 0 ? statusCodes : [],
+        addedOn: getAddedOnVersion(program, response.type),
+        discriminator: "basic",
+        type: type
+    };
+}
+function emitOperation(context, operation, operationGroupName) {
+    const lro = isLro(context.program, operation);
+    const paging = getPagedResult(context.program, operation);
+    if (lro && paging) {
+        return emitLroPagingOperation(context, operation, operationGroupName);
+    }
+    else if (paging) {
+        return emitPagingOperation(context, operation, operationGroupName);
+    }
+    else if (lro) {
+        return emitLroOperation(context, operation, operationGroupName);
+    }
+    return emitBasicOperation(context, operation, operationGroupName);
+}
+function addLroInformation(emittedOperation) {
+    emittedOperation["discriminator"] = "lro";
+}
+function addPagingInformation(program, operation, emittedOperation) {
+    emittedOperation["discriminator"] = "paging";
+    const pagedResult = getPagedResult(program, operation);
+    if (pagedResult === undefined) {
+        throw Error("Trying to add paging information, but not paging metadata for this operation");
+    }
+    emittedOperation["itemName"] = pagedResult.itemsPath;
+    emittedOperation["continuationTokenName"] = pagedResult.nextLinkPath;
+}
+function emitLroPagingOperation(context, operation, operationGroupName) {
+    const emittedOperation = emitBasicOperation(context, operation, operationGroupName);
+    addLroInformation(emittedOperation);
+    addPagingInformation(context.program, operation, emittedOperation);
+    emittedOperation["discriminator"] = "lropaging";
+    return emittedOperation;
+}
+function emitLroOperation(context, operation, operationGroupName) {
+    const emittedOperation = emitBasicOperation(context, operation, operationGroupName);
+    addLroInformation(emittedOperation);
+    return emittedOperation;
+}
+function emitPagingOperation(context, operation, operationGroupName) {
+    const emittedOperation = emitBasicOperation(context, operation, operationGroupName);
+    addPagingInformation(context.program, operation, emittedOperation);
+    return emittedOperation;
+}
+function emitBasicOperation(context, operation, operationGroupName) {
+    var _a;
+    // Set up parameters for operation
+    const parameters = [];
+    if (endpointPathParameters) {
+        for (const param of endpointPathParameters) {
+            parameters.push(param);
+        }
+    }
+    const httpOperation = ignoreDiagnostics(getHttpOperation(context.program, operation));
+    for (const param of httpOperation.parameters.parameters) {
+        const emittedParam = emitParameter(context, param, "Method");
+        if (isApiVersion(context, param) && apiVersionParam === undefined) {
+            apiVersionParam = emittedParam;
+        }
+        parameters.push(emittedParam);
+    }
+    // Set up responses for operation
+    const responses = [];
+    const exceptions = [];
+    const isOverload = false;
+    const isOverriden = false;
+    for (const response of httpOperation.responses) {
+        for (const innerResponse of response.responses) {
+            const emittedResponse = emitResponse(context.program, response, innerResponse);
+            if (emittedResponse["type"] &&
+                parameters.filter((e) => e.restApiName.toLowerCase() === "accept")
+                    .length === 0) {
+                parameters.push(emitAcceptParameter(context.program, isOverload, isOverriden));
+            }
+            if (isErrorModel(context.program, response.type)) {
+                // * is valid status code in cadl but invalid for autorest.python
+                if (response.statusCode === "*") {
+                    exceptions.push(emittedResponse);
+                }
+            }
+            else {
+                responses.push(emittedResponse);
+            }
+        }
+    }
+    let bodyParameter;
+    if (httpOperation.parameters.body === undefined) {
+        bodyParameter = undefined;
+    }
+    else {
+        bodyParameter = emitBodyParameter(context.program, httpOperation);
+        if (parameters.filter((e) => e.restApiName.toLowerCase() === "content-type")
+            .length === 0) {
+            parameters.push(emitContentTypeParameter(bodyParameter, isOverload, isOverriden));
+        }
+        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(operation.name, { casing: CASING });
+    return {
+        name: name,
+        description: getDocStr(context.program, operation),
+        summary: (_a = getSummary(context.program, operation)) !== null && _a !== void 0 ? _a : "",
+        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: false,
+        overloads: [],
+        apiVersions: [getAddedOnVersion(context.program, operation)]
+    };
+}
+function isReadOnly(program, type) {
+    // https://microsoft.github.io/cadl/standard-library/rest/operations#automatic-visibility
+    // Only "read" should be readOnly
+    const visibility = getVisibility(program, type);
+    if (visibility) {
+        return visibility.includes("read");
+    }
+    else {
+        return false;
+    }
+}
+function emitProperty(program, property) {
+    var _a;
+    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;
+    }
+    const restApiName = getProjectedName(program, property, "json");
+    return {
+        clientName: applyCasing(property.name, { casing: CASING }),
+        restApiName: restApiName !== null && restApiName !== void 0 ? restApiName : property.name,
+        type: getType(program, property.type),
+        optional: property.optional,
+        description: getDocStr(program, property),
+        addedOn: getAddedOnVersion(program, property),
+        readonly: isReadOnly(program, property) || isKey(program, property),
+        clientDefaultValue: clientDefaultValue
+    };
+}
+function getName(program, type) {
+    const friendlyName = getFriendlyName(program, type);
+    if (friendlyName) {
+        return friendlyName;
+    }
+    else {
+        if (type.templateMapper &&
+            type.templateMapper.args &&
+            type.templateMapper.args.length > 0) {
+            return (type.name +
+                type.templateMapper.args
+                    .map((it) => (it.kind === "Model" ? it.name : ""))
+                    .join(""));
+        }
+        else {
+            return type.name;
+        }
+    }
+}
+function emitModel(program, type) {
+    // Now we know it's a defined model
+    const properties = [];
+    let baseModel = undefined;
+    if (type.baseModel) {
+        baseModel = getType(program, type.baseModel);
+    }
+    const effectiveName = getEffectiveSchemaType(program, type).name;
+    const modelName = effectiveName ? effectiveName : getName(program, type);
+    return {
+        type: "model",
+        name: modelName,
+        description: getDocStr(program, type),
+        parents: baseModel ? [baseModel] : [],
+        discriminatedSubtypes: {},
+        properties: properties,
+        addedOn: getAddedOnVersion(program, type),
+        snakeCaseName: modelName
+            ? applyCasing(modelName, { casing: CASING })
+            : modelName,
+        base: modelName === "" ? "json" : "dpg"
+    };
+}
+function intOrFloat(value) {
+    return value.toString().indexOf(".") === -1 ? "integer" : "float";
+}
+function enumName(name) {
+    if (name.toUpperCase() === name) {
+        return name;
+    }
+    return applyCasing(name, { casing: CASING }).toUpperCase();
+}
+function emitEnum(program, type) {
+    var _a;
+    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)
+        });
+    }
+    return {
+        type: "enum",
+        name: type.name,
+        description: getDocStr(program, type),
+        valueType: { type: enumMemberType(type.members.values().next().value) },
+        values: enumValues,
+        isFixed: isFixed(program, type)
+    };
+    function enumMemberType(member) {
+        if (typeof member.value === "number") {
+            return intOrFloat(member.value);
+        }
+        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
+            }
+        };
+    }
+    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(scalar) {
+    switch (scalar.name) {
+        case "bytes":
+            return { type: "byte-array", format: "byte" };
+        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: "date" };
+        case "utcDateTime":
+            return { type: "datetime", format: "date-time" };
+        case "plainTime":
+            return { type: "time" };
+        case "duration":
+            return { type: "duration" };
+        case "numeric":
+            return {}; // Waiting on design for more precise type https://github.com/microsoft/cadl/issues/1260
+        default:
+            return {};
+    }
+}
+function applyIntrinsicDecorators(program, type, result) {
+    const 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;
+    }
+    const formatStr = getFormat(program, type);
+    if (isString && !result.format && formatStr) {
+        newResult.format = formatStr;
+    }
+    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 = {};
+    if (program.checker.isStdType(scalar)) {
+        result = emitStdScalar(scalar);
+    }
+    else if (scalar.baseScalar) {
+        result = emitScalar(program, scalar.baseScalar);
+    }
+    return applyIntrinsicDecorators(program, scalar, result);
+}
+function emitListOrDict(program, type) {
+    if (type.indexer !== undefined) {
+        if (!isNeverType(type.indexer.key)) {
+            const name = type.indexer.key.name;
+            if (name === "string") {
+                return {
+                    type: "dict",
+                    elementType: getType(program, type.indexer.value)
+                };
+            }
+            else if (name === "integer") {
+                return {
+                    type: "list",
+                    elementType: getType(program, type.indexer.value)
+                };
+            }
+        }
+    }
+    return undefined;
+}
+function mapCadlType(program, type) {
+    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(program, type);
+    }
+}
+function capitalize(name) {
+    return name[0].toUpperCase() + name.slice(1);
+}
+function emitUnion(program, type) {
+    const nonNullOptions = [...type.variants.values()]
+        .map((x) => x.type)
+        .filter((t) => !isNullType(t));
+    const notLiteral = (t) => ["Boolean", "Number", "String"].indexOf(t.kind) < 0;
+    if (nonNullOptions.length > 1) {
+        if (nonNullOptions.every(notLiteral)) {
+            // Generate as CombinedType if non of the options is Literal.
+            const unionName = `MyCombinedType`;
+            return {
+                name: unionName,
+                snakeCaseName: applyCasing(unionName, { casing: CASING }),
+                description: `Type of ${unionName}`,
+                isPublic: false,
+                type: "combined",
+                types: nonNullOptions.map((x) => emitType(program, x)),
+                xmlMetadata: {}
+            };
+        }
+        else if (nonNullOptions.some(notLiteral)) {
+            // Can't generate if this union is a mixed up of literals and sub-types
+            throw Error(`Can't do union for ${JSON.stringify(nonNullOptions)}`);
+        }
+    }
+    // Geneate Union of Literals as Python Enum
+    const values = [];
+    for (const option of nonNullOptions) {
+        const value = emitType(program, option)["value"];
+        values.push({
+            description: "",
+            name: applyCasing(value, { casing: CASING }).toUpperCase(),
+            value: value
+        });
+    }
+    let enumName = "MyEnum";
+    if (type.node &&
+        type.node.parent &&
+        [SyntaxKind.ModelStatement, SyntaxKind.ModelProperty].includes(type.node.parent.kind)) {
+        if (type.node.parent.kind === SyntaxKind.ModelStatement) {
+            enumName = capitalize(type.node.parent.id.sv);
+        }
+        else if (type.node.parent.kind === SyntaxKind.ModelProperty) {
+            const parent = type.node.parent;
+            if (parent.id.sv) {
+                enumName = capitalize(parent.id.sv) + "Type";
+            }
+        }
+    }
+    return {
+        name: enumName,
+        snakeCaseName: applyCasing(enumName, { casing: CASING }),
+        description: `Type of ${enumName}`,
+        isPublic: false,
+        type: "enum",
+        valueType: emitType(program, nonNullOptions[0])["valueType"],
+        values: values,
+        xmlMetadata: {}
+    };
+}
+function emitType(program, type) {
+    if (type.kind === "Credential") {
+        return emitCredential(type.scheme);
+    }
+    if (type.kind === "CredentialTypeUnion") {
+        return emitCredentialUnion(type);
+    }
+    const builtinType = mapCadlType(program, type);
+    if (builtinType !== undefined) {
+        // add in description elements for types derived from primitive types (SecureString, etc.)
+        const doc = getDoc(program, type);
+        if (doc) {
+            builtinType.description = doc;
+        }
+        return builtinType;
+    }
+    switch (type.kind) {
+        case "Intrinsic":
+            return { type: "any" };
+        case "Model":
+            return emitModel(program, type);
+        case "Scalar":
+            return emitScalar(program, type);
+        case "Union":
+            return emitUnion(program, type);
+        case "UnionVariant":
+            return {};
+        case "Enum":
+            return emitEnum(program, type);
+        default:
+            throw Error(`Not supported ${type.kind}`);
+    }
+}
+function emitOperationGroups(context, client) {
+    const operationGroups = [];
+    for (const operationGroup of listOperationGroups(context, client)) {
+        const operations = [];
+        const name = operationGroup.type.name;
+        for (const operation of listOperationsInOperationGroup(context, operationGroup)) {
+            operations.push(emitOperation(context, operation, name));
+        }
+        operationGroups.push({
+            className: name,
+            propertyName: name,
+            operations: operations
+        });
+    }
+    const clientOperations = [];
+    for (const operation of listOperationsInOperationGroup(context, client)) {
+        clientOperations.push(emitOperation(context, operation, ""));
+    }
+    if (clientOperations.length > 0) {
+        operationGroups.push({
+            className: "",
+            propertyName: "",
+            operations: clientOperations
+        });
+    }
+    return operationGroups;
+}
+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) {
+        return [
+            {
+                optional: false,
+                description: "Service host",
+                clientName: "endpoint",
+                clientDefaultValue: null,
+                restApiName: "$host",
+                location: "path",
+                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");
+            endpointPathParameters.push(emittedParameter);
+            if (isApiVersion(context, serverParameter) &&
+                apiVersionParam == undefined) {
+                apiVersionParam = emittedParameter;
+                continue;
+            }
+            params.push(emittedParameter);
+        }
+        return params;
+    }
+    else {
+        return [
+            {
+                optional: false,
+                description: "Service host",
+                clientName: "endpoint",
+                clientDefaultValue: server.url,
+                restApiName: "$host",
+                location: "path",
+                type: { type: "string" },
+                implementation: "Client",
+                inOverload: false
+            }
+        ];
+    }
+}
+function emitCredentialParam(program, namespace) {
+    const auth = getAuthentication(program, namespace);
+    if (auth) {
+        const credential_types = [];
+        for (const option of auth.options) {
+            for (const scheme of option.schemes) {
+                const type = {
+                    kind: "Credential",
+                    scheme: scheme
+                };
+                credential_types.push(type);
+            }
+        }
+        if (credential_types.length > 0) {
+            let type;
+            if (credential_types.length === 1 && credential_types[0]) {
+                type = credential_types[0];
+            }
+            else {
+                type = {
+                    kind: "CredentialTypeUnion",
+                    types: credential_types
+                };
+            }
+            return {
+                type: getType(program, type),
+                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.program, namespace);
+    if (credentialParam) {
+        clientParameters.push(credentialParam);
+    }
+    return clientParameters;
+}
+function getApiVersionParameter(context) {
+    const version = getDefaultApiVersion(context, getServiceNamespace(context.program));
+    if (apiVersionParam) {
+        return { ...apiVersionParam, isApiVersion: true };
+    }
+    else if (version !== undefined) {
+        return {
+            clientName: "api_version",
+            clientDefaultValue: version.value,
+            description: "Api Version",
+            implementation: "Client",
+            location: "query",
+            restApiName: "api-version",
+            skipUrlEncoding: false,
+            optional: false,
+            inDocstring: true,
+            inOverload: false,
+            inOverriden: false,
+            type: getConstantType(version.value),
+            isApiVersion: true
+        };
+    }
+}
+function emitClients(context, namespace) {
+    var _a;
+    const program = context.program;
+    const clients = listClients(context);
+    const retval = [];
+    for (const client of clients) {
+        const clientName = client.name.replace("Client", "");
+        if (getNamespace(context, client.name) !== namespace) {
+            continue;
+        }
+        const server = getServerHelper(program, client.service);
+        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),
+            url: server ? server.url : "",
+            apiVersions: []
+        };
+        const emittedApiVersionParam = getApiVersionParameter(context);
+        if (emittedApiVersionParam) {
+            emittedClient.parameters.push(emittedApiVersionParam);
+        }
+        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(context, options = { casing: "snake" }) {
+    var _a, _b;
+    CASING = (_a = options.casing) !== null && _a !== void 0 ? _a : CASING;
+    const dpgContext = createSdkContext(context);
+    const clientNamespaceString = (_b = getClientNamespaceString(dpgContext)) === null || _b === void 0 ? void 0 : _b.toLowerCase();
+    // Get types
+    const codeModel = {
+        options: transformRLCOptions(context.program, context.options, context.emitterOutputDir, dpgContext),
+        namespace: clientNamespaceString,
+        subnamespaceToClients: {},
+        clients: [],
+        types: []
+    };
+    for (const namespace of getNamespaces(dpgContext)) {
+        if (namespace === clientNamespaceString) {
+            codeModel.clients = emitClients(dpgContext, namespace);
+        }
+        else {
+            codeModel["subnamespaceToClients"][namespace] = emitClients(dpgContext, namespace);
+        }
+    }
+    codeModel.types = [
+        ...[...typesMap.values()].filter((t) => t.name !== "object"),
+        { type: "string" },
+        ...simpleTypesMap.values()
+    ];
+    return codeModel;
+}
+//# sourceMappingURL=buildCodeModel.js.map