@azure-tools/typespec-python 0.7.0

package/dist/src/emitter.js

@@ -0,0 +1,1149 @@
+import { getPagedResult } 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, getNamespaceFullName, } from "@typespec/compiler";
+import { getAuthentication, getHeaderFieldName, getHttpOperation, getPathParamName, getQueryParamName, getServers, isStatusCode, isHeader, } from "@typespec/http";
+import { getAddedOn } from "@typespec/versioning";
+import { listClients, listOperationGroups, listOperationsInOperationGroup, isApiVersion, getDefaultApiVersion, getClientNamespaceString, getClientFormat, createDpgContext, getPropertyNames, getLibraryName, getAllModels, } from "@azure-tools/typespec-client-generator-core";
+import { getResourceOperation } from "@typespec/rest";
+import { resolveModuleRoot, saveCodeModelAsYaml } from "./external-process.js";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+import { dump } from "js-yaml";
+import { execFileSync } from "child_process";
+const defaultOptions = {
+    "basic-setup-py": true,
+    "package-version": "1.0.0b1",
+};
+export async function $onEmit(context) {
+    const program = context.program;
+    const resolvedOptions = { ...defaultOptions, ...context.options };
+    const root = await resolveModuleRoot(program, "@autorest/python", dirname(fileURLToPath(import.meta.url)));
+    const outputDir = context.emitterOutputDir;
+    const yamlMap = emitCodeModel(context);
+    const yamlPath = await saveCodeModelAsYaml("typespec-python-yaml-map", yamlMap);
+    const commandArgs = [
+        `${root}/run-python3.js`,
+        `${root}/run_cadl.py`,
+        `--output-folder=${outputDir}`,
+        `--cadl-file=${yamlPath}`,
+    ];
+    for (const [key, value] of Object.entries(resolvedOptions)) {
+        commandArgs.push(`--${key}=${value}`);
+    }
+    if (resolvedOptions.debug) {
+        commandArgs.push("--debug");
+    }
+    if (!program.compilerOptions.noEmit && !program.hasError()) {
+        execFileSync(process.execPath, commandArgs);
+    }
+}
+function camelToSnakeCase(name) {
+    if (!name)
+        return name;
+    const camelToSnakeCaseRe = (str) => str
+        .replace(/\s+/g, "_")
+        .replace(/\$/g, "")
+        .replace(/-/g, "_")
+        .replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+    return camelToSnakeCaseRe(name[0].toLowerCase() + name.slice(1));
+}
+const typesMap = new Map();
+const simpleTypesMap = new Map();
+const endpointPathParameters = [];
+let apiVersionParam = undefined;
+function isSimpleType(context, 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(context.program, type)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function getDocStr(context, target) {
+    var _a;
+    return (_a = getDoc(context.program, target)) !== null && _a !== void 0 ? _a : "";
+}
+function isLro(operation) {
+    for (const decorator of operation.decorators) {
+        if (decorator.decorator.name === "$pollingOperation") {
+            return true;
+        }
+    }
+    return false;
+}
+function handleDiscriminator(context, type, model) {
+    const discriminator = getDiscriminator(context.program, type);
+    if (discriminator) {
+        let discriminatorProperty;
+        for (const childModel of type.derivedModels) {
+            const modelType = getType(context, 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(context, type) {
+    const program = context.program;
+    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 getEntityType(context, entity) {
+    const result = getType(context, entity.type);
+    const format = getClientFormat(context, entity);
+    if (format) {
+        if (format === "rfc1123") {
+            result["format"] = "date-time-rfc1123";
+        }
+        else if (format === "iso8601") {
+            result["format"] = "date-time";
+        }
+    }
+    return result;
+}
+function getType(context, type) {
+    // don't cache simple type(string, int, etc) since decorators may change the result
+    const program = context.program;
+    const enableCache = !isSimpleType(context, type);
+    const effectiveModel = type.kind === "Model" ? getEffectiveSchemaType(context, type) : type;
+    if (enableCache) {
+        const cached = typesMap.get(effectiveModel);
+        if (cached) {
+            return cached;
+        }
+    }
+    let newValue = emitType(context, 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(context, property));
+            }
+            // need to do discriminator outside `emitModel` to avoid infinite recursion
+            handleDiscriminator(context, type, newValue);
+        }
+    }
+    else {
+        const key = dump(newValue, { sortKeys: true });
+        const value = simpleTypesMap.get(key);
+        if (value) {
+            newValue = value;
+        }
+        else {
+            simpleTypesMap.set(key, newValue);
+        }
+    }
+    return newValue;
+}
+// To pass the yaml dump
+function getAddedOnVersion(context, t) {
+    var _a;
+    return (_a = getAddedOn(context.program, t)) === null || _a === void 0 ? void 0 : _a.value;
+}
+function emitParamBase(context, parameter) {
+    let optional;
+    let name;
+    let description = "";
+    let addedOn;
+    if (parameter.kind === "ModelProperty") {
+        optional = parameter.optional;
+        name = parameter.name;
+        description = getDocStr(context, parameter);
+        addedOn = getAddedOnVersion(context, parameter);
+    }
+    else {
+        optional = false;
+        name = "body";
+    }
+    return {
+        optional,
+        description,
+        addedOn,
+        clientName: camelToSnakeCase(name),
+        inOverload: false,
+    };
+}
+function getBodyType(context, 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(context.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(context, responseBody.type);
+                    // response body type is reosurce type, and request body type (if templated) contains resource type
+                    if (bodyTypeInResponse === resourceType &&
+                        bodyModel.templateArguments &&
+                        bodyModel.templateArguments.some((it) => {
+                            return it.kind === "Model" || it.kind === "Union" ? it === bodyTypeInResponse : false;
+                        })) {
+                        bodyModel = resourceType;
+                    }
+                }
+            }
+        }
+        if (resourceType && bodyModel.name === "") {
+            bodyModel = resourceType;
+        }
+    }
+    return bodyModel;
+}
+function emitBodyParameter(context, httpOperation) {
+    var _a, _b, _c, _d, _e;
+    const params = httpOperation.parameters;
+    const body = params.body;
+    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"];
+    }
+    if (contentTypes.length !== 1) {
+        throw Error("Currently only one kind of content-type!");
+    }
+    const type = getType(context, getBodyType(context, 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, parameter.param);
+    let type = getEntityType(context, parameter.param);
+    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.type === "path" ? parameter.param.name : parameter.name,
+        location: parameter.type,
+        type: type,
+        implementation: implementation,
+        skipUrlEncoding: parameter.type === "endpointPath",
+    };
+    if (type.type === "list" && (parameter.type === "query" || parameter.type === "header")) {
+        if (parameter.format === "csv") {
+            paramMap["delimiter"] = "comma";
+        }
+        else {
+            paramMap["explode"] = true;
+        }
+    }
+    if (paramMap.type.type === "constant") {
+        clientDefaultValue = paramMap.type.value;
+    }
+    if (isApiVersion(context, parameter)) {
+        const defaultApiVersion = getDefaultApiVersion(context, getServiceNamespace(context));
+        paramMap.type = defaultApiVersion ? getConstantType(defaultApiVersion.value) : KnownTypes.string;
+        paramMap.implementation = "Client";
+        paramMap.in_docstring = false;
+        paramMap.isApiVersion = true;
+        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: KnownTypes.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: KnownTypes.string,
+        xmlMetadata: {},
+    };
+    simpleTypesMap.set(key, type);
+    return type;
+}
+function emitAcceptParameter(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(context, headers) {
+    const retval = [];
+    if (!headers) {
+        return retval;
+    }
+    for (const [key, value] of Object.entries(headers)) {
+        retval.push({
+            type: getEntityType(context, value),
+            restApiName: key,
+        });
+    }
+    return retval;
+}
+function isAzureCoreModel(t) {
+    return (t.kind === "Model" &&
+        t.namespace !== undefined &&
+        ["Azure.Core", "Azure.Core.Foundations"].includes(getNamespaceFullName(t.namespace)));
+}
+function emitResponse(context, response, innerResponse) {
+    var _a;
+    let type = undefined;
+    if ((_a = innerResponse.body) === null || _a === void 0 ? void 0 : _a.type) {
+        let modelType = undefined;
+        if (innerResponse.body.type.kind === "Model") {
+            modelType = getEffectiveSchemaType(context, innerResponse.body.type);
+        }
+        if (modelType && !isAzureCoreModel(modelType)) {
+            type = getType(context, modelType);
+        }
+        else if (modelType && ["CustomPage", "Page"].includes(modelType.name)) {
+            // hacky sorry. we want a dummy type here so we get the accept parameter
+            // we don't want to generate the paged models
+            type = getType(context, Array.from(modelType.properties.values())[0].type);
+        }
+        else if (!modelType) {
+            type = getType(context, innerResponse.body.type);
+        }
+    }
+    const statusCodes = [];
+    if (response.statusCode === "*") {
+        statusCodes.push("default");
+    }
+    else {
+        statusCodes.push(parseInt(response.statusCode));
+    }
+    return {
+        headers: emitResponseHeaders(context, innerResponse.headers),
+        statusCodes: statusCodes,
+        addedOn: getAddedOnVersion(context, response.type),
+        discriminator: "basic",
+        type: type,
+    };
+}
+function emitOperation(context, operation, operationGroupName) {
+    const lro = isLro(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, initialOperation) {
+    emittedOperation["discriminator"] = "lro";
+    emittedOperation["initialOperation"] = initialOperation;
+    emittedOperation["exposeStreamKeyword"] = false;
+}
+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"] = pagedResult.itemsPath;
+    emittedOperation["itemType"] = getType(context, pagedResult.itemsProperty.type);
+    emittedOperation["continuationTokenName"] = pagedResult.nextLinkPath;
+    emittedOperation["exposeStreamKeyword"] = false;
+}
+function getLroInitialOperation(context, operation, operationGroupName) {
+    const initialOperation = emitBasicOperation(context, operation, operationGroupName)[0];
+    initialOperation["name"] = `_${initialOperation["name"]}_initial`;
+    initialOperation["isLroInitialOperation"] = true;
+    initialOperation["wantTracing"] = false;
+    initialOperation["exposeStreamKeyword"] = false;
+    return initialOperation;
+}
+function emitLroPagingOperation(context, operation, operationGroupName) {
+    const retval = [];
+    for (const emittedOperation of emitBasicOperation(context, operation, operationGroupName)) {
+        const initialOperation = getLroInitialOperation(context, operation, operationGroupName);
+        addLroInformation(emittedOperation, initialOperation);
+        addPagingInformation(context, operation, emittedOperation);
+        emittedOperation["discriminator"] = "lropaging";
+        retval.push(emittedOperation);
+    }
+    return retval;
+}
+function emitLroOperation(context, operation, operationGroupName) {
+    const retval = [];
+    for (const emittedOperation of emitBasicOperation(context, operation, operationGroupName)) {
+        const initialOperation = getLroInitialOperation(context, operation, operationGroupName);
+        addLroInformation(emittedOperation, initialOperation);
+        retval.push(initialOperation);
+        retval.push(emittedOperation);
+    }
+    return retval;
+}
+function emitPagingOperation(context, operation, operationGroupName) {
+    const retval = [];
+    for (const emittedOperation of emitBasicOperation(context, operation, operationGroupName)) {
+        addPagingInformation(context, operation, emittedOperation);
+        retval.push(emittedOperation);
+    }
+    return retval;
+}
+function emitBasicOperation(context, operation, operationGroupName) {
+    // 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, response, innerResponse);
+            if (emittedResponse["type"] &&
+                parameters.filter((e) => e.restApiName.toLowerCase() === "accept").length === 0) {
+                parameters.push(emitAcceptParameter(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, 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 = camelToSnakeCase(getLibraryName(context, operation));
+    return [
+        {
+            name: name,
+            description: getDocStr(context, operation),
+            summary: getSummary(context.program, operation),
+            url: httpOperation.path,
+            method: httpOperation.verb.toUpperCase(),
+            parameters: parameters,
+            bodyParameter: bodyParameter,
+            responses: responses,
+            exceptions: exceptions,
+            groupName: operationGroupName,
+            addedOn: getAddedOnVersion(context, operation),
+            discriminator: "basic",
+            isOverload: false,
+            overloads: [],
+            apiVersions: [getAddedOnVersion(context, operation)],
+            wantTracing: true,
+            exposeStreamKeyword: true,
+        },
+    ];
+}
+function isReadOnly(context, type) {
+    // https://microsoft.github.io/cadl/standard-library/rest/operations#automatic-visibility
+    // Only "read" should be readOnly
+    const visibility = getVisibility(context.program, type);
+    if (visibility) {
+        return visibility.includes("read");
+    }
+    else {
+        return false;
+    }
+}
+function emitProperty(context, 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 [clientName, jsonName] = getPropertyNames(context, property);
+    return {
+        clientName: camelToSnakeCase(clientName),
+        restApiName: jsonName,
+        type: getEntityType(context, property),
+        optional: property.optional,
+        description: getDocStr(context, property),
+        addedOn: getAddedOnVersion(context, property),
+        readonly: isReadOnly(context, property) || isKey(context.program, property),
+        clientDefaultValue: clientDefaultValue,
+    };
+}
+function getName(context, type) {
+    const friendlyName = getFriendlyName(context.program, type);
+    if (friendlyName) {
+        return friendlyName;
+    }
+    else {
+        const modelName = getLibraryName(context, type);
+        if (type.templateArguments && type.templateArguments.length > 0) {
+            return modelName + type.templateArguments.map((it) => (it.kind === "Model" ? it.name : "")).join("");
+        }
+        else {
+            return modelName;
+        }
+    }
+}
+function emitModel(context, type) {
+    // Now we know it's a defined model
+    const properties = [];
+    let baseModel = undefined;
+    if (type.baseModel) {
+        baseModel = getType(context, type.baseModel);
+    }
+    const modelName = getName(context, type) || getEffectiveSchemaType(context, type).name;
+    return {
+        type: "model",
+        name: modelName,
+        description: getDocStr(context, type),
+        parents: baseModel ? [baseModel] : [],
+        discriminatedSubtypes: {},
+        properties: properties,
+        addedOn: getAddedOnVersion(context, type),
+        snakeCaseName: modelName ? camelToSnakeCase(modelName) : 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 camelToSnakeCase(name).toUpperCase();
+}
+function emitEnum(context, 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(context, m),
+        });
+    }
+    return {
+        type: "enum",
+        name: type.name,
+        description: getDocStr(context, type),
+        valueType: { type: enumMemberType(type.members.values().next().value) },
+        values: enumValues,
+    };
+    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 "zonedDateTime":
+            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(context, type, result) {
+    const program = context.program;
+    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(context, scalar) {
+    let result = {};
+    if (context.program.checker.isStdType(scalar)) {
+        result = emitStdScalar(scalar);
+    }
+    else if (scalar.baseScalar) {
+        result = emitScalar(context, scalar.baseScalar);
+    }
+    return applyIntrinsicDecorators(context, scalar, result);
+}
+function emitListOrDict(context, type) {
+    if (type.indexer !== undefined) {
+        if (isNeverType(type.indexer.key)) {
+        }
+        else {
+            const name = type.indexer.key.name;
+            const elementType = type.indexer.value;
+            if (name === "string") {
+                if (elementType.kind === "Intrinsic") {
+                }
+                return { type: "dict", elementType: getType(context, type.indexer.value) };
+            }
+            else if (name === "integer") {
+                return { type: "list", elementType: getType(context, type.indexer.value) };
+            }
+        }
+    }
+    return undefined;
+}
+function mapCadlType(context, 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(context, type);
+    }
+}
+function capitalize(name) {
+    return name[0].toUpperCase() + name.slice(1);
+}
+function emitUnion(context, 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.every(notLiteral)) {
+        if (nonNullOptions.length === 1) {
+            // Generate as internal type if there is only one internal type in this Union.
+            return emitType(context, nonNullOptions[0]);
+        }
+        // Generate as CombinedType if non of the options is Literal.
+        const unionName = type.name;
+        return {
+            name: unionName,
+            snakeCaseName: camelToSnakeCase(unionName || ""),
+            description: `Type of ${unionName}`,
+            isPublic: false,
+            type: "combined",
+            types: nonNullOptions.map((x) => getType(context, 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(context, option)["value"];
+        values.push({
+            description: "",
+            name: camelToSnakeCase(value).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: camelToSnakeCase(enumName),
+        description: `Type of ${enumName}`,
+        isPublic: false,
+        type: "enum",
+        valueType: emitType(context, nonNullOptions[0])["valueType"],
+        values: values,
+        xmlMetadata: {},
+    };
+}
+function emitType(context, type) {
+    if (type.kind === "Credential") {
+        return emitCredential(type.scheme);
+    }
+    if (type.kind === "CredentialTypeUnion") {
+        return emitCredentialUnion(type);
+    }
+    const builtinType = mapCadlType(context, type);
+    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: "any" };
+        case "Model":
+            return emitModel(context, type);
+        case "Scalar":
+            return emitScalar(context, type);
+        case "Union":
+            return emitUnion(context, type);
+        case "UnionVariant":
+            return {};
+        case "Enum":
+            return emitEnum(context, type);
+        default:
+            throw Error(`Not supported ${type.kind}`);
+    }
+}
+function emitOperationGroups(context, client) {
+    const operationGroups = [];
+    for (const operationGroup of listOperationGroups(context, client)) {
+        let operations = [];
+        const name = operationGroup.type.name;
+        for (const operation of listOperationsInOperationGroup(context, operationGroup)) {
+            operations = operations.concat(emitOperation(context, operation, name));
+        }
+        operationGroups.push({
+            className: name,
+            propertyName: name,
+            operations: operations,
+        });
+    }
+    let clientOperations = [];
+    for (const operation of listOperationsInOperationGroup(context, client)) {
+        clientOperations = clientOperations.concat(emitOperation(context, operation, ""));
+    }
+    if (clientOperations.length > 0) {
+        operationGroups.push({
+            className: "",
+            propertyName: "",
+            operations: clientOperations,
+        });
+    }
+    return operationGroups;
+}
+function getServerHelper(context, namespace) {
+    const servers = getServers(context.program, namespace);
+    if (servers === undefined) {
+        return undefined;
+    }
+    return servers[0];
+}
+function emitServerParams(context, namespace) {
+    const server = getServerHelper(context, namespace);
+    if (server === undefined) {
+        return [
+            {
+                optional: false,
+                description: "Service host",
+                clientName: "endpoint",
+                clientDefaultValue: null,
+                restApiName: "$host",
+                location: "path",
+                type: KnownTypes.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: KnownTypes.string,
+                implementation: "Client",
+                inOverload: false,
+            },
+        ];
+    }
+}
+function emitCredentialParam(context, namespace) {
+    const auth = getAuthentication(context.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) {
+                type = credential_types[0];
+            }
+            else {
+                type = {
+                    kind: "CredentialTypeUnion",
+                    types: credential_types,
+                };
+            }
+            return {
+                type: getType(context, 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, namespace);
+    if (credentialParam) {
+        clientParameters.push(credentialParam);
+    }
+    return clientParameters;
+}
+function getApiVersionParameter(context) {
+    const version = getDefaultApiVersion(context, getServiceNamespace(context));
+    if (apiVersionParam) {
+        return apiVersionParam;
+    }
+    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,
+            inOverridden: false,
+            type: getConstantType(version.value),
+            isApiVersion: true,
+        };
+    }
+}
+function emitClients(context, namespace) {
+    const clients = listClients(context);
+    const retval = [];
+    for (const client of clients) {
+        if (getNamespace(context, client.name) !== namespace) {
+            continue;
+        }
+        const server = getServerHelper(context, client.service);
+        const emittedClient = {
+            name: client.name.split(".").at(-1),
+            description: getDocStr(context, 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(context) {
+    return listServices(context.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;
+}
+function emitCodeModel(context) {
+    var _a;
+    const dpgContext = createDpgContext(context);
+    const clientNamespaceString = (_a = getClientNamespaceString(dpgContext)) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    // Get types
+    const codeModel = {
+        namespace: clientNamespaceString,
+        subnamespaceToClients: {},
+    };
+    for (const model of getAllModels(dpgContext)) {
+        getType(dpgContext, model);
+    }
+    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(), ...Object.values(KnownTypes), ...simpleTypesMap.values()];
+    return codeModel;
+}
+const KnownTypes = {
+    string: { type: "string" },
+};
+//# sourceMappingURL=emitter.js.map