@azure-tools/typespec-autorest-canonical 0.3.0-dev.5 → 0.3.0

package/dist/src/openapi.js

@@ -1,1714 +0,0 @@
-import { getRef } from "@azure-tools/typespec-autorest";
-import { getAsEmbeddingVector, getLroMetadata, getPagedResult, getUnionAsEnum, isFixed, } from "@azure-tools/typespec-azure-core";
-import { createSdkContext, getClientNameOverride, shouldFlattenProperty, } from "@azure-tools/typespec-client-generator-core";
-import { SyntaxKind, TwoLevelMap, compilerAssert, emitFile, getAllTags, getDirectoryPath, getDiscriminator, getDoc, getEncode, getFormat, getKnownValues, getMaxItems, getMaxLength, getMaxValue, getMinItems, getMinLength, getMinValue, getNamespaceFullName, getPattern, getProjectedName, getProperty, getPropertyType, getRelativePathFromDirectory, getRootLength, getService, getSummary, getVisibility, ignoreDiagnostics, interpolatePath, isArrayModelType, isDeprecated, isErrorModel, isErrorType, isGlobalNamespace, isNeverType, isNullType, isNumericType, isRecordModelType, isSecret, isService, isStringType, isTemplateDeclaration, isTemplateDeclarationOrInstance, isVoidType, listServices, navigateTypesInNamespace, resolveEncodedName, resolvePath, stringTemplateToString, } from "@typespec/compiler";
-import { Visibility, createMetadataInfo, getAllHttpServices, getAuthentication, getHeaderFieldOptions, getQueryParamOptions, getServers, getStatusCodeDescription, getVisibilitySuffix, isContentTypeHeader, isSharedRoute, reportIfNoRoutes, resolveRequestVisibility, } from "@typespec/http";
-import { checkDuplicateTypeName, getExtensions, getExternalDocs, getOpenAPITypeName, getParameterKey, isReadonlyProperty, resolveInfo, shouldInline, } from "@typespec/openapi";
-import { getRenamedFrom, getReturnTypeChangedFrom, getTypeChangedFrom, getVersion, } from "@typespec/versioning";
-import { AutorestCanonicalOpenAPISchema } from "./autorest-canonical-openapi-schema.js";
-import { sortWithJsonSchema } from "./json-schema-sorter/sorter.js";
-import { getTracer, reportDiagnostic } from "./lib.js";
-import { resolveOperationId } from "./utils.js";
-const defaultOptions = {
-    "output-file": "{azure-resource-provider-folder}/{service-name}/{version}/openapi.json",
-    "new-line": "lf",
-    "include-x-typespec-name": "never",
-};
-var UnsupportedVersioningDecorators;
-(function (UnsupportedVersioningDecorators) {
-    UnsupportedVersioningDecorators["RenamedFrom"] = "renamedFrom";
-    UnsupportedVersioningDecorators["ReturnTypeChangedFrom"] = "returnTypeChangedFrom";
-    UnsupportedVersioningDecorators["TypeChangedFrom"] = "typeChangedFrom";
-})(UnsupportedVersioningDecorators || (UnsupportedVersioningDecorators = {}));
-export const canonicalVersion = "canonical";
-export const namespace = "AutorestCanonical";
-export async function $onEmit(context) {
-    const resolvedOptions = { ...defaultOptions, ...context.options };
-    const tcgcSdkContext = createSdkContext(context, "@azure-tools/typespec-autorest-canonical");
-    const armTypesDir = interpolatePath(resolvedOptions["arm-types-dir"] ?? "{project-root}/../../common-types/resource-management", {
-        "project-root": context.program.projectRoot,
-        "emitter-output-dir": context.emitterOutputDir,
-    });
-    const options = {
-        outputFile: resolvedOptions["output-file"],
-        outputDir: context.emitterOutputDir,
-        azureResourceProviderFolder: resolvedOptions["azure-resource-provider-folder"],
-        newLine: resolvedOptions["new-line"],
-        omitUnreachableTypes: resolvedOptions["omit-unreachable-types"],
-        includeXTypeSpecName: resolvedOptions["include-x-typespec-name"],
-        armTypesDir,
-    };
-    const emitter = createOAPIEmitter(context.program, tcgcSdkContext, options);
-    await emitter.emitOpenAPI();
-}
-function getEmitterDetails(program) {
-    return [{ emitter: "@azure-tools/typespec-autorest-canonical" }];
-}
-/**
- * Represents a node that will hold a JSON reference. The value is computed
- * at the end so that we can defer decisions about the name that is
- * referenced.
- */
-class Ref {
-    value;
-    toJSON() {
-        compilerAssert(this.value, "Reference value never set.");
-        return this.value;
-    }
-}
-function createOAPIEmitter(program, tcgcSdkContext, options) {
-    const tracer = getTracer(program);
-    tracer.trace("options", JSON.stringify(options, null, 2));
-    const typeNameOptions = {
-        // shorten type names by removing TypeSpec and service namespace
-        namespaceFilter(ns) {
-            return !isService(program, ns);
-        },
-    };
-    let root;
-    let currentService;
-    let currentEndpoint;
-    let currentConsumes;
-    let currentProduces;
-    let metadataInfo;
-    // Keep a map of all Types+Visibility combinations that were encountered
-    // that need schema definitions.
-    let pendingSchemas = new TwoLevelMap();
-    // Reuse a single ref object per Type+Visibility combination.
-    let refs = new TwoLevelMap();
-    // Keep track of inline types still in the process of having their schema computed
-    // This is used to detect cycles in inline types, which is an
-    let inProgressInlineTypes = new Set();
-    // Map model properties that represent shared parameters to their parameter
-    // definition that will go in #/parameters. Inlined parameters do not go in
-    // this map.
-    let params;
-    // Keep track of models that have had properties spread into parameters. We won't
-    // consider these unreferenced when emitting unreferenced types.
-    let paramModels;
-    // De-dupe the per-endpoint tags that will be added into the #/tags
-    let tags;
-    // The set of produces/consumes values found in all operations
-    const globalProduces = new Set(["application/json"]);
-    const globalConsumes = new Set(["application/json"]);
-    let outputFile;
-    let context;
-    async function emitOpenAPI() {
-        const services = listServices(program);
-        if (services.length === 0) {
-            services.push({ type: program.getGlobalNamespaceType() });
-        }
-        for (const service of services) {
-            currentService = service;
-            context = {
-                program,
-                service,
-                version: canonicalVersion,
-                getClientName,
-            };
-            const projectedServiceNs = service.type;
-            await emitOpenAPIFromVersion(projectedServiceNs === program.getGlobalNamespaceType()
-                ? { type: program.getGlobalNamespaceType() }
-                : getService(program, projectedServiceNs), services.length > 1, canonicalVersion);
-        }
-    }
-    return { emitOpenAPI };
-    function initializeEmitter(service, multipleService, version) {
-        const auth = processAuth(service.type);
-        const includedVersions = getVersion(program, service.type)
-            ?.getVersions()
-            ?.map((item) => item.name);
-        const info = resolveInfo(program, service.type);
-        root = {
-            swagger: "2.0",
-            info: {
-                title: service.title ?? "(title)",
-                ...info,
-                version: version ?? info?.version ?? "0000-00-00",
-                "x-typespec-generated": getEmitterDetails(program),
-                "x-canonical-included-versions": includedVersions,
-            },
-            schemes: ["https"],
-            ...resolveHost(program, service.type),
-            externalDocs: getExternalDocs(program, service.type),
-            produces: [], // Pre-initialize produces and consumes so that
-            consumes: [], // they show up at the top of the document
-            security: auth?.security,
-            securityDefinitions: auth?.securitySchemes ?? {},
-            tags: [],
-            paths: {},
-            "x-ms-paths": {},
-            definitions: {},
-            parameters: {},
-        };
-        pendingSchemas = new TwoLevelMap();
-        refs = new TwoLevelMap();
-        metadataInfo = createMetadataInfo(program, {
-            canonicalVisibility: Visibility.Read,
-            canShareProperty: canSharePropertyUsingReadonlyOrXMSMutability,
-        });
-        inProgressInlineTypes = new Set();
-        params = new Map();
-        paramModels = new Set();
-        tags = new Set();
-        outputFile = resolveOutputFile(program, service, multipleService, options, version);
-    }
-    function resolveHost(program, namespace) {
-        const servers = getServers(program, namespace);
-        if (servers === undefined) {
-            return {};
-        }
-        // If there is more than one server we then just make a custom host with a parameter asking for the full url.
-        if (servers.length > 1) {
-            return {
-                "x-ms-parameterized-host": {
-                    hostTemplate: "{url}",
-                    useSchemePrefix: false,
-                    parameters: [
-                        {
-                            name: "url",
-                            in: "path",
-                            description: "Url",
-                            type: "string",
-                            format: "uri",
-                            "x-ms-skip-url-encoding": true,
-                        },
-                    ],
-                },
-            };
-        }
-        const server = servers[0];
-        if (server.parameters.size === 0) {
-            const [scheme, host] = server.url.split("://");
-            return {
-                host,
-                schemes: [scheme],
-            };
-        }
-        const parameters = [];
-        for (const prop of server.parameters.values()) {
-            const param = getOpenAPI2Parameter(prop, "path", {
-                visibility: Visibility.Read,
-                ignoreMetadataAnnotations: false,
-            });
-            if (prop.type.kind === "Scalar" &&
-                ignoreDiagnostics(program.checker.isTypeAssignableTo(prop.type.projectionBase ?? prop.type, program.checker.getStdType("url"), prop.type))) {
-                param["x-ms-skip-url-encoding"] = true;
-            }
-            parameters.push(param);
-        }
-        return {
-            "x-ms-parameterized-host": {
-                hostTemplate: server.url,
-                useSchemePrefix: false,
-                parameters,
-            },
-        };
-    }
-    async function emitOpenAPIFromVersion(service, multipleService, version) {
-        initializeEmitter(service, multipleService, version);
-        try {
-            const services = ignoreDiagnostics(getAllHttpServices(program));
-            const routes = services[0].operations;
-            reportIfNoRoutes(program, routes);
-            routes.forEach(emitOperation);
-            emitParameters();
-            emitSchemas(service.type);
-            emitTags();
-            // Finalize global produces/consumes
-            if (globalProduces.size > 0) {
-                root.produces = [...globalProduces.values()];
-            }
-            else {
-                delete root.produces;
-            }
-            if (globalConsumes.size > 0) {
-                root.consumes = [...globalConsumes.values()];
-            }
-            else {
-                delete root.consumes;
-            }
-            // Clean up empty entries
-            if (root["x-ms-paths"] && Object.keys(root["x-ms-paths"]).length === 0) {
-                delete root["x-ms-paths"];
-            }
-            if (root.security && Object.keys(root.security).length === 0) {
-                delete root["security"];
-            }
-            if (root.securityDefinitions && Object.keys(root.securityDefinitions).length === 0) {
-                delete root["securityDefinitions"];
-            }
-            if (!program.compilerOptions.noEmit && !program.hasError()) {
-                // Sort the document
-                const sortedRoot = sortOpenAPIDocument(root);
-                // Write out the OpenAPI document to the output path
-                await emitFile(program, {
-                    path: outputFile,
-                    content: prettierOutput(JSON.stringify(sortedRoot, null, 2)),
-                    newLine: options.newLine,
-                });
-            }
-        }
-        catch (err) {
-            if (err instanceof ErrorTypeFoundError) {
-                // Return early, there must be a parse error if an ErrorType was
-                // inserted into the TypeSpec output
-                return;
-            }
-            else {
-                throw err;
-            }
-        }
-    }
-    function parseNextLinkName(paged) {
-        const pathComponents = paged.nextLinkSegments;
-        if (pathComponents) {
-            return pathComponents[pathComponents.length - 1];
-        }
-        return undefined;
-    }
-    function extractPagedMetadataNested(program, type) {
-        // This only works for `is Page<T>` not `extends Page<T>`.
-        let paged = getPagedResult(program, type);
-        if (paged) {
-            return paged;
-        }
-        if (type.baseModel) {
-            paged = getPagedResult(program, type.baseModel);
-        }
-        if (paged) {
-            return paged;
-        }
-        const templateArguments = type.templateMapper;
-        if (templateArguments) {
-            for (const argument of templateArguments.args) {
-                const modelArgument = argument;
-                if (modelArgument) {
-                    paged = extractPagedMetadataNested(program, modelArgument);
-                    if (paged) {
-                        return paged;
-                    }
-                }
-            }
-        }
-        return paged;
-    }
-    function extractPagedMetadata(program, operation) {
-        for (const response of operation.responses) {
-            const paged = extractPagedMetadataNested(program, response.type);
-            if (paged) {
-                const nextLinkName = parseNextLinkName(paged);
-                if (nextLinkName) {
-                    currentEndpoint["x-ms-pageable"] = {
-                        nextLinkName,
-                    };
-                }
-                // Once we find paged metadata, we don't need to processes any further.
-                return;
-            }
-        }
-    }
-    function requiresXMsPaths(path, operation) {
-        const isShared = isSharedRoute(program, operation) ?? false;
-        if (path.includes("?")) {
-            return true;
-        }
-        return isShared;
-    }
-    function getPathWithoutQuery(path) {
-        // strip everything from the key including and after the ?
-        return path.replace(/\/?\?.*/, "");
-    }
-    function emitOperation(operation) {
-        let { path: fullPath, operation: op, verb, parameters } = operation;
-        let pathsObject = root.paths;
-        if (getReturnTypeChangedFrom(program, operation.operation)) {
-            reportDisallowedDecorator(UnsupportedVersioningDecorators.ReturnTypeChangedFrom, operation.operation);
-        }
-        const pathWithoutAnyQuery = getPathWithoutQuery(fullPath);
-        if (root.paths[pathWithoutAnyQuery]?.[verb] === undefined) {
-            fullPath = pathWithoutAnyQuery;
-            pathsObject = root.paths;
-        }
-        else if (requiresXMsPaths(fullPath, op)) {
-            // if the key already exists in x-ms-paths, append
-            // the operation id.
-            if (fullPath.includes("?")) {
-                if (root["x-ms-paths"]?.[fullPath] !== undefined) {
-                    fullPath += `&_overload=${operation.operation.name}`;
-                }
-            }
-            else {
-                fullPath += `?_overload=${operation.operation.name}`;
-            }
-            pathsObject = root["x-ms-paths"];
-        }
-        else {
-            // This should not happen because http library should have already validated duplicate path or the routes must have been using shared routes and so goes in previous condition.
-            compilerAssert(false, `Duplicate route "${fullPath}". This is unexpected.`);
-        }
-        if (!pathsObject[fullPath]) {
-            pathsObject[fullPath] = {};
-        }
-        const currentPath = pathsObject[fullPath];
-        if (!currentPath[verb]) {
-            currentPath[verb] = {};
-        }
-        currentEndpoint = currentPath[verb];
-        currentConsumes = new Set();
-        currentProduces = new Set();
-        const currentTags = getAllTags(program, op);
-        if (currentTags) {
-            currentEndpoint.tags = currentTags;
-            for (const tag of currentTags) {
-                // Add to root tags if not already there
-                tags.add(tag);
-            }
-        }
-        currentEndpoint.operationId = resolveOperationId(context, op);
-        applyExternalDocs(op, currentEndpoint);
-        // Set up basic endpoint fields
-        currentEndpoint.summary = getSummary(program, op);
-        currentEndpoint.description = getDoc(program, op);
-        currentEndpoint.parameters = [];
-        currentEndpoint.responses = {};
-        const lroMetadata = getLroMetadata(program, op);
-        // We ignore GET operations because they cannot be LROs per our guidelines and this
-        // ensures we don't add the x-ms-long-running-operation extension to the polling operation,
-        // which does have LRO metadata.
-        if (lroMetadata !== undefined && operation.verb !== "get") {
-            currentEndpoint["x-ms-long-running-operation"] = true;
-        }
-        // Extract paged metadata from Azure.Core.Page
-        extractPagedMetadata(program, operation);
-        const visibility = resolveRequestVisibility(program, operation.operation, verb);
-        emitEndpointParameters(parameters, visibility);
-        emitResponses(operation.responses);
-        applyEndpointConsumes();
-        applyEndpointProduces();
-        if (isDeprecated(program, op)) {
-            currentEndpoint.deprecated = true;
-        }
-        // Attach additional extensions after main fields
-        attachExtensions(op, currentEndpoint);
-    }
-    function applyEndpointProduces() {
-        if (currentProduces.size > 0 && !checkLocalAndGlobalEqual(globalProduces, currentProduces)) {
-            currentEndpoint.produces = [...currentProduces];
-        }
-    }
-    function applyEndpointConsumes() {
-        if (currentConsumes.size > 0 && !checkLocalAndGlobalEqual(globalConsumes, currentConsumes)) {
-            currentEndpoint.consumes = [...currentConsumes];
-        }
-    }
-    function checkLocalAndGlobalEqual(global, local) {
-        if (global.size !== local.size) {
-            return false;
-        }
-        for (const entry of local) {
-            if (!global.has(entry)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    function isBytes(type) {
-        const baseType = type.projectionBase ?? type;
-        return ignoreDiagnostics(program.checker.isTypeAssignableTo(baseType, program.checker.getStdType("bytes"), type));
-    }
-    function isBinaryPayload(body, contentType) {
-        const types = new Set(typeof contentType === "string" ? [contentType] : contentType);
-        return (body.kind === "Scalar" &&
-            body.name === "bytes" &&
-            !types.has("application/json") &&
-            !types.has("text/plain"));
-    }
-    function emitResponses(responses) {
-        for (const response of responses) {
-            for (const statusCode of getOpenAPI2StatusCodes(response.statusCodes, response.type)) {
-                emitResponseObject(statusCode, response);
-            }
-        }
-    }
-    function getOpenAPI2StatusCodes(statusCodes, diagnosticTarget) {
-        if (statusCodes === "*") {
-            return ["default"];
-        }
-        else if (typeof statusCodes === "number") {
-            return [String(statusCodes)];
-        }
-        else {
-            return rangeToOpenAPI(statusCodes, diagnosticTarget);
-        }
-    }
-    function rangeToOpenAPI(range, diagnosticTarget) {
-        const reportInvalid = () => reportDiagnostic(program, {
-            code: "unsupported-status-code-range",
-            format: { start: String(range.start), end: String(range.end) },
-            target: diagnosticTarget,
-        });
-        const codes = [];
-        let start = range.start;
-        let end = range.end;
-        if (range.start < 100) {
-            reportInvalid();
-            start = 100;
-            codes.push("default");
-        }
-        else if (range.end > 599) {
-            reportInvalid();
-            codes.push("default");
-            end = 599;
-        }
-        const groups = [1, 2, 3, 4, 5];
-        for (const group of groups) {
-            if (start > end) {
-                break;
-            }
-            const groupStart = group * 100;
-            const groupEnd = groupStart + 99;
-            if (start >= groupStart && start <= groupEnd) {
-                codes.push(`${group}XX`);
-                if (start !== groupStart || end < groupEnd) {
-                    reportInvalid();
-                }
-                start = groupStart + 100;
-            }
-        }
-        return codes;
-    }
-    function getResponseDescriptionForStatusCode(statusCode) {
-        if (statusCode === "default") {
-            return "An unexpected error response.";
-        }
-        return getStatusCodeDescription(statusCode) ?? "unknown";
-    }
-    function emitResponseObject(statusCode, response) {
-        const openapiResponse = currentEndpoint.responses[statusCode] ?? {
-            description: response.description ?? getResponseDescriptionForStatusCode(statusCode),
-        };
-        if (isErrorModel(program, response.type) && statusCode !== "default") {
-            openapiResponse["x-ms-error-response"] = true;
-        }
-        const contentTypes = [];
-        let body;
-        for (const data of response.responses) {
-            if (data.headers && Object.keys(data.headers).length > 0) {
-                openapiResponse.headers ??= {};
-                for (const [key, value] of Object.entries(data.headers)) {
-                    openapiResponse.headers[key] = getResponseHeader(value);
-                }
-            }
-            if (data.body) {
-                if (body && body.type !== data.body.type) {
-                    reportDiagnostic(program, {
-                        code: "duplicate-body-types",
-                        target: response.type,
-                    });
-                }
-                body = data.body;
-                contentTypes.push(...data.body.contentTypes);
-            }
-        }
-        if (body) {
-            const isBinary = contentTypes.every((t) => isBinaryPayload(body.type, t));
-            openapiResponse.schema = isBinary
-                ? { type: "file" }
-                : getSchemaOrRef(body.type, {
-                    visibility: Visibility.Read,
-                    ignoreMetadataAnnotations: body.isExplicit && body.containsMetadataAnnotations,
-                });
-        }
-        for (const contentType of contentTypes) {
-            currentProduces.add(contentType);
-        }
-        currentEndpoint.responses[statusCode] = openapiResponse;
-    }
-    function getResponseHeader(prop) {
-        const header = {};
-        populateParameter(header, prop, "header", {
-            visibility: Visibility.Read,
-            ignoreMetadataAnnotations: false,
-        });
-        delete header.in;
-        delete header.name;
-        delete header.required;
-        return header;
-    }
-    function resolveRef(ref) {
-        const absoluteRef = interpolatePath(ref, {
-            "arm-types-dir": options.armTypesDir,
-        });
-        if (getRootLength(absoluteRef) === 0) {
-            return absoluteRef; // It is already relative.
-        }
-        return getRelativePathFromDirectory(getDirectoryPath(outputFile), absoluteRef, false);
-    }
-    function getSchemaOrRef(type, schemaContext) {
-        const refUrl = getRef(program, type, { version: context.version, service: context.service });
-        if (refUrl) {
-            return {
-                $ref: resolveRef(refUrl),
-            };
-        }
-        if (type.kind === "Scalar" && program.checker.isStdType(type)) {
-            return getSchemaForScalar(type);
-        }
-        if (type.kind === "String" || type.kind === "Number" || type.kind === "Boolean") {
-            // For literal types, we just want to emit them directly as well.
-            return getSchemaForLiterals(type);
-        }
-        if (type.kind === "StringTemplate") {
-            return getSchemaForStringTemplate(type);
-        }
-        if (type.kind === "Intrinsic" && type.name === "unknown") {
-            return getSchemaForIntrinsicType(type);
-        }
-        if (type.kind === "EnumMember") {
-            // Enum members are just the OA representation of their values.
-            if (typeof type.value === "number") {
-                return { type: "number", enum: [type.value] };
-            }
-            else {
-                return { type: "string", enum: [type.value ?? type.name] };
-            }
-        }
-        if (type.kind === "ModelProperty") {
-            return resolveProperty(type, schemaContext);
-        }
-        type = metadataInfo.getEffectivePayloadType(type, schemaContext.visibility);
-        const name = getOpenAPITypeName(program, type, typeNameOptions);
-        if (shouldInline(program, type)) {
-            const schema = getSchemaForInlineType(type, name, schemaContext);
-            if (schema === undefined && isErrorType(type)) {
-                // Exit early so that syntax errors are exposed.  This error will
-                // be caught and handled in emitOpenAPI.
-                throw new ErrorTypeFoundError();
-            }
-            // helps to read output and correlate to TypeSpec
-            if (schema && options.includeXTypeSpecName !== "never") {
-                schema["x-typespec-name"] = name;
-            }
-            return schema;
-        }
-        else {
-            // Use shared schema when type is not transformed by visibility from the canonical read visibility.
-            if (!metadataInfo.isTransformed(type, schemaContext.visibility)) {
-                schemaContext = { ...schemaContext, visibility: Visibility.Read };
-            }
-            const pending = pendingSchemas.getOrAdd(type, schemaContext.visibility, () => ({
-                type,
-                visibility: schemaContext.visibility,
-                ref: refs.getOrAdd(type, schemaContext.visibility, () => new Ref()),
-            }));
-            return { $ref: pending.ref };
-        }
-    }
-    function getSchemaForInlineType(type, name, context) {
-        if (inProgressInlineTypes.has(type)) {
-            reportDiagnostic(program, {
-                code: "inline-cycle",
-                format: { type: name },
-                target: type,
-            });
-            return {};
-        }
-        inProgressInlineTypes.add(type);
-        const schema = getSchemaForType(type, context);
-        inProgressInlineTypes.delete(type);
-        return schema;
-    }
-    function getParamPlaceholder(property) {
-        let spreadParam = false;
-        if (property.sourceProperty) {
-            // chase our sources all the way back to the first place this property
-            // was defined.
-            spreadParam = true;
-            property = property.sourceProperty;
-            while (property.sourceProperty) {
-                property = property.sourceProperty;
-            }
-        }
-        const refUrl = getRef(program, property, {
-            version: context.version,
-            service: context.service,
-        });
-        if (refUrl) {
-            return {
-                $ref: resolveRef(refUrl),
-            };
-        }
-        const parameter = params.get(property);
-        if (parameter) {
-            return parameter;
-        }
-        const placeholder = {};
-        // only parameters inherited by spreading from non-inlined type are shared in #/parameters
-        if (spreadParam && property.model && !shouldInline(program, property.model)) {
-            params.set(property, placeholder);
-            paramModels.add(property.model);
-        }
-        return placeholder;
-    }
-    function getJsonName(type) {
-        const viaProjection = getProjectedName(program, type, "json");
-        const encodedName = resolveEncodedName(program, type, "application/json");
-        // Pick the value set via `encodedName` or default back to the legacy projection otherwise.
-        // `resolveEncodedName` will return the original name if no @encodedName so we have to do that check
-        return encodedName === type.name ? viaProjection ?? type.name : encodedName;
-    }
-    function getClientName(type) {
-        const viaProjection = getProjectedName(program, type, "client");
-        const clientName = getClientNameOverride(tcgcSdkContext, type);
-        return clientName ?? viaProjection ?? type.name;
-    }
-    function emitEndpointParameters(methodParams, visibility) {
-        const consumes = methodParams.body?.contentTypes ?? [];
-        for (const httpOpParam of methodParams.parameters) {
-            const shared = params.get(httpOpParam.param);
-            if (shared) {
-                currentEndpoint.parameters.push(shared);
-                continue;
-            }
-            if (httpOpParam.type === "header" && isContentTypeHeader(program, httpOpParam.param)) {
-                continue;
-            }
-            emitParameter(httpOpParam.param, httpOpParam.type, { visibility, ignoreMetadataAnnotations: false }, httpOpParam.name);
-        }
-        if (consumes.length === 0 && methodParams.body) {
-            // we didn't find an explicit content type anywhere, so infer from body.
-            if (getModelOrScalarTypeIfNullable(methodParams.body.type)) {
-                consumes.push("application/json");
-            }
-        }
-        for (const consume of consumes) {
-            currentConsumes.add(consume);
-        }
-        if (methodParams.body && !isVoidType(methodParams.body.type)) {
-            const isBinary = isBinaryPayload(methodParams.body.type, consumes);
-            const schemaContext = {
-                visibility,
-                ignoreMetadataAnnotations: methodParams.body.isExplicit && methodParams.body.containsMetadataAnnotations,
-            };
-            const schema = isBinary
-                ? { type: "string", format: "binary" }
-                : getSchemaOrRef(methodParams.body.type, schemaContext);
-            if (currentConsumes.has("multipart/form-data")) {
-                const bodyModelType = methodParams.body.type;
-                // Assert, this should never happen. Rest library guard against that.
-                compilerAssert(bodyModelType.kind === "Model", "Body should always be a Model.");
-                if (bodyModelType) {
-                    for (const param of bodyModelType.properties.values()) {
-                        emitParameter(param, "formData", schemaContext, getJsonName(param));
-                    }
-                }
-            }
-            else if (methodParams.body.parameter) {
-                emitParameter(methodParams.body.parameter, "body", { visibility, ignoreMetadataAnnotations: false }, getJsonName(methodParams.body.parameter), schema);
-            }
-            else {
-                currentEndpoint.parameters.push({
-                    name: "body",
-                    in: "body",
-                    schema,
-                    required: true,
-                });
-            }
-        }
-    }
-    function getModelOrScalarTypeIfNullable(type) {
-        if (type.kind === "Model" || type.kind === "Scalar") {
-            return type;
-        }
-        else if (type.kind === "Union") {
-            // Remove all `null` types and make sure there's a single model type
-            const nonNulls = [...type.variants.values()]
-                .map((x) => x.type)
-                .filter((variant) => !isNullType(variant));
-            if (nonNulls.every((t) => t.kind === "Model" || t.kind === "Scalar")) {
-                return nonNulls.length === 1 ? nonNulls[0] : undefined;
-            }
-        }
-        return undefined;
-    }
-    function emitParameter(param, kind, schemaContext, name, typeOverride) {
-        if (isNeverType(param.type)) {
-            return;
-        }
-        const ph = getParamPlaceholder(param);
-        currentEndpoint.parameters.push(ph);
-        // If the parameter already has a $ref, don't bother populating it
-        if (!("$ref" in ph)) {
-            populateParameter(ph, param, kind, schemaContext, name, typeOverride);
-        }
-    }
-    function getSchemaForPrimitiveItems(type, schemaContext, paramName, multipart) {
-        const fullSchema = getSchemaForType(type, schemaContext);
-        if (fullSchema === undefined) {
-            return undefined;
-        }
-        if (fullSchema.type === "object") {
-            reportDiagnostic(program, {
-                code: multipart ? "unsupported-multipart-type" : "unsupported-param-type",
-                format: { part: paramName },
-                target: type,
-            });
-            return { type: "string" };
-        }
-        return fullSchema;
-    }
-    function getFormDataSchema(type, schemaContext, paramName) {
-        if (isBytes(type)) {
-            return { type: "file" };
-        }
-        if (type.kind === "Model" && isArrayModelType(program, type)) {
-            const schema = getSchemaForPrimitiveItems(type.indexer.value, schemaContext, paramName, true);
-            if (schema === undefined) {
-                return undefined;
-            }
-            delete schema.description;
-            return {
-                type: "array",
-                items: schema,
-            };
-        }
-        else {
-            const schema = getSchemaForPrimitiveItems(type, schemaContext, paramName, true);
-            if (schema === undefined) {
-                return undefined;
-            }
-            return schema;
-        }
-    }
-    function getOpenAPI2Parameter(param, kind, schemaContext, name, bodySchema) {
-        const ph = {
-            name: name ?? param.name,
-            in: kind,
-            required: !param.optional,
-            description: getDoc(program, param),
-        };
-        if (param.name !== ph.name) {
-            ph["x-ms-client-name"] = param.name;
-        }
-        if (param.default) {
-            ph.default = getDefaultValue(param.default);
-        }
-        if (ph.in === "body") {
-            compilerAssert(bodySchema, "bodySchema argument is required to populate body parameter");
-            ph.schema = bodySchema;
-        }
-        else if (ph.in === "formData") {
-            Object.assign(ph, getFormDataSchema(param.type, schemaContext, ph.name));
-        }
-        else {
-            const collectionFormat = (kind === "query"
-                ? getQueryParamOptions(program, param)
-                : kind === "header"
-                    ? getHeaderFieldOptions(program, param)
-                    : undefined)?.format;
-            if (collectionFormat === "multi" && !["query", "header", "formData"].includes(ph.in)) {
-                reportDiagnostic(program, { code: "invalid-multi-collection-format", target: param });
-            }
-            if (collectionFormat) {
-                ph.collectionFormat = collectionFormat;
-            }
-            if (param.type.kind === "Model" && isArrayModelType(program, param.type)) {
-                ph.type = "array";
-                const schema = {
-                    ...getSchemaForPrimitiveItems(param.type.indexer.value, schemaContext, ph.name),
-                };
-                delete schema.description;
-                ph.items = schema;
-            }
-            else {
-                Object.assign(ph, getSchemaForPrimitiveItems(param.type, schemaContext, ph.name));
-            }
-        }
-        attachExtensions(param, ph);
-        // Apply decorators to a copy of the parameter definition.  We use
-        // Object.assign here because applyIntrinsicDecorators returns a new object
-        // based on the target object and we need to apply its changes back to the
-        // original parameter.
-        Object.assign(ph, applyIntrinsicDecorators(param, { type: ph.type, format: ph.format }));
-        return ph;
-    }
-    function populateParameter(ph, param, kind, schemaContext, name, bodySchema) {
-        Object.assign(ph, getOpenAPI2Parameter(param, kind, schemaContext, name, bodySchema));
-    }
-    function emitParameters() {
-        for (const [property, param] of params) {
-            // Add an extension which tells AutorestCanonical that this is a shared operation
-            // parameter definition
-            if (param["x-ms-parameter-location"] === undefined) {
-                param["x-ms-parameter-location"] = "method";
-            }
-            const key = getParameterKey(program, property, param, root.parameters, typeNameOptions);
-            root.parameters[key] = { ...param };
-            const refedParam = param;
-            for (const key of Object.keys(param)) {
-                delete refedParam[key];
-            }
-            refedParam["$ref"] = "#/parameters/" + encodeURIComponent(key);
-        }
-    }
-    function emitSchemas(serviceNamespace) {
-        const processedSchemas = new TwoLevelMap();
-        processSchemas();
-        if (!options.omitUnreachableTypes) {
-            processUnreferencedSchemas();
-        }
-        // Emit the processed schemas. Only now can we compute the names as it
-        // depends on whether we have produced multiple schemas for a single
-        // TYPESPEC type.
-        for (const group of processedSchemas.values()) {
-            for (const [visibility, processed] of group) {
-                let name = getOpenAPITypeName(program, processed.type, typeNameOptions);
-                if (group.size > 1) {
-                    name += getVisibilitySuffix(visibility, Visibility.Read);
-                }
-                checkDuplicateTypeName(program, processed.type, name, root.definitions);
-                processed.ref.value = "#/definitions/" + encodeURIComponent(name);
-                if (processed.schema) {
-                    root.definitions[name] = processed.schema;
-                }
-            }
-        }
-        function processSchemas() {
-            // Process pending schemas. Note that getSchemaForType may pull in new
-            // pending schemas so we iterate until there are no pending schemas
-            // remaining.
-            while (pendingSchemas.size > 0) {
-                for (const [type, group] of pendingSchemas) {
-                    for (const [visibility, pending] of group) {
-                        processedSchemas.getOrAdd(type, visibility, () => ({
-                            ...pending,
-                            schema: getSchemaForType(type, {
-                                visibility: visibility,
-                                ignoreMetadataAnnotations: false,
-                            }),
-                        }));
-                    }
-                    pendingSchemas.delete(type);
-                }
-            }
-        }
-        function processUnreferencedSchemas() {
-            const addSchema = (type) => {
-                if (!processedSchemas.has(type) && !paramModels.has(type) && !shouldInline(program, type)) {
-                    getSchemaOrRef(type, { visibility: Visibility.Read, ignoreMetadataAnnotations: false });
-                }
-            };
-            const skipSubNamespaces = isGlobalNamespace(program, serviceNamespace);
-            navigateTypesInNamespace(serviceNamespace, {
-                model: addSchema,
-                scalar: addSchema,
-                enum: addSchema,
-                union: addSchema,
-            }, { skipSubNamespaces });
-            processSchemas();
-        }
-    }
-    function emitTags() {
-        for (const tag of tags) {
-            root.tags.push({ name: tag });
-        }
-    }
-    function getSchemaForType(type, schemaContext) {
-        const builtinType = getSchemaForLiterals(type);
-        if (builtinType !== undefined) {
-            return builtinType;
-        }
-        switch (type.kind) {
-            case "Intrinsic":
-                return getSchemaForIntrinsicType(type);
-            case "Model":
-                return getSchemaForModel(type, schemaContext);
-            case "ModelProperty":
-                return getSchemaForType(type.type, schemaContext);
-            case "Scalar":
-                return getSchemaForScalar(type);
-            case "Union":
-                return getSchemaForUnion(type, schemaContext);
-            case "UnionVariant":
-                return getSchemaForUnionVariant(type, schemaContext);
-            case "Enum":
-                return getSchemaForEnum(type);
-            case "Tuple":
-                return { type: "array", items: {} };
-        }
-        reportDiagnostic(program, {
-            code: "invalid-schema",
-            format: { type: type.kind },
-            target: type,
-        });
-        return undefined;
-    }
-    function getSchemaForIntrinsicType(type) {
-        switch (type.name) {
-            case "unknown":
-                return {};
-        }
-        reportDiagnostic(program, {
-            code: "invalid-schema",
-            format: { type: type.name },
-            target: type,
-        });
-        return {};
-    }
-    function getSchemaForEnum(e) {
-        const values = [];
-        if (e.members.size === 0) {
-            reportUnsupportedUnion("empty");
-            return {};
-        }
-        const type = getEnumMemberType(e.members.values().next().value);
-        for (const option of e.members.values()) {
-            if (type !== getEnumMemberType(option)) {
-                reportUnsupportedUnion();
-                continue;
-            }
-            else {
-                values.push(option.value ?? option.name);
-            }
-        }
-        const schema = { type, description: getDoc(program, e) };
-        if (values.length > 0) {
-            schema.enum = values;
-            addXMSEnum(e, schema);
-        }
-        return schema;
-        function getEnumMemberType(member) {
-            if (typeof member.value === "number") {
-                return "number";
-            }
-            return "string";
-        }
-        function reportUnsupportedUnion(messageId = "default") {
-            reportDiagnostic(program, { code: "union-unsupported", messageId, target: e });
-        }
-    }
-    function getSchemaForUnionEnum(union, e) {
-        const values = [];
-        let foundCustom = false;
-        for (const [name, member] of e.flattenedMembers.entries()) {
-            const description = getDoc(program, member.type);
-            values.push({
-                name: typeof name === "string" ? name : `${member.value}`,
-                value: member.value,
-                description,
-            });
-            if (description || typeof name === "string") {
-                foundCustom = true;
-            }
-        }
-        const schema = {
-            type: e.kind,
-            enum: [...e.flattenedMembers.values()].map((x) => x.value),
-            "x-ms-enum": {
-                name: union.name,
-                modelAsString: e.open,
-            },
-        };
-        if (foundCustom) {
-            schema["x-ms-enum"].values = values;
-        }
-        if (e.nullable) {
-            schema["x-nullable"] = true;
-        }
-        return applyIntrinsicDecorators(union, schema);
-    }
-    function getSchemaForUnion(union, schemaContext) {
-        const nonNullOptions = [...union.variants.values()]
-            .map((x) => x.type)
-            .filter((t) => !isNullType(t));
-        const nullable = union.variants.size !== nonNullOptions.length;
-        if (nonNullOptions.length === 0) {
-            reportDiagnostic(program, { code: "union-null", target: union });
-            return {};
-        }
-        if (nonNullOptions.length === 1) {
-            const type = nonNullOptions[0];
-            // Get the schema for the model type
-            const schema = getSchemaOrRef(type, schemaContext);
-            if (schema.$ref) {
-                if (type.kind === "Model") {
-                    return { type: "object", allOf: [schema], "x-nullable": nullable };
-                }
-                else {
-                    return { ...schema, "x-nullable": nullable };
-                }
-            }
-            else {
-                schema["x-nullable"] = nullable;
-                return schema;
-            }
-        }
-        else {
-            const [asEnum, _] = getUnionAsEnum(union);
-            if (asEnum) {
-                return getSchemaForUnionEnum(union, asEnum);
-            }
-            reportDiagnostic(program, {
-                code: "union-unsupported",
-                target: union,
-            });
-            return {};
-        }
-    }
-    function ifArrayItemContainsIdentifier(program, array) {
-        if (array.indexer.value?.kind !== "Model") {
-            return true;
-        }
-        return (getExtensions(program, array).has("x-ms-identifiers") ||
-            getProperty(array.indexer.value, "id"));
-    }
-    function getSchemaForUnionVariant(variant, schemaContext) {
-        return getSchemaForType(variant.type, schemaContext);
-    }
-    function getDefaultValue(type) {
-        switch (type.kind) {
-            case "String":
-                return type.value;
-            case "Number":
-                return type.value;
-            case "Boolean":
-                return type.value;
-            case "Tuple":
-                return type.values.map(getDefaultValue);
-            case "EnumMember":
-                return type.value ?? type.name;
-            case "Intrinsic":
-                return isNullType(type)
-                    ? null
-                    : reportDiagnostic(program, {
-                        code: "invalid-default",
-                        format: { type: type.kind },
-                        target: type,
-                    });
-            case "UnionVariant":
-                return getDefaultValue(type.type);
-            default:
-                reportDiagnostic(program, {
-                    code: "invalid-default",
-                    format: { type: type.kind },
-                    target: type,
-                });
-        }
-    }
-    function includeDerivedModel(model) {
-        return (!isTemplateDeclaration(model) &&
-            (model.templateMapper?.args === undefined ||
-                model.templateMapper?.args.length === 0 ||
-                model.derivedModels.length > 0));
-    }
-    function reportDisallowedDecorator(decorator, type) {
-        reportDiagnostic(program, {
-            code: "unsupported-versioning-decorator",
-            format: { decorator },
-            target: type,
-        });
-    }
-    function getSchemaForModel(model, schemaContext) {
-        const array = getArrayType(model, schemaContext);
-        if (array) {
-            return array;
-        }
-        const modelSchema = {
-            type: "object",
-            description: getDoc(program, model),
-        };
-        if (model.baseModel) {
-            const discriminator = getDiscriminator(program, model.baseModel);
-            if (discriminator) {
-                const prop = getProperty(model, discriminator.propertyName);
-                if (prop) {
-                    const values = getStringValues(prop.type);
-                    if (values.length === 1) {
-                        const extensions = getExtensions(program, model);
-                        if (!extensions.has("x-ms-discriminator-value")) {
-                            modelSchema["x-ms-discriminator-value"] = values[0];
-                        }
-                    }
-                }
-            }
-        }
-        const properties = {};
-        if (isRecordModelType(program, model)) {
-            modelSchema.additionalProperties = getSchemaOrRef(model.indexer.value, schemaContext);
-        }
-        const derivedModels = model.derivedModels.filter(includeDerivedModel);
-        // getSchemaOrRef on all children to push them into components.schemas
-        for (const child of derivedModels) {
-            getSchemaOrRef(child, schemaContext);
-        }
-        const discriminator = getDiscriminator(program, model);
-        if (discriminator) {
-            const { propertyName } = discriminator;
-            modelSchema.discriminator = propertyName;
-            // Push discriminator into base type, but only if it is not already there
-            if (!model.properties.get(propertyName)) {
-                properties[propertyName] = {
-                    type: "string",
-                    description: `Discriminator property for ${model.name}.`,
-                };
-                modelSchema.required = [propertyName];
-            }
-        }
-        applyExternalDocs(model, modelSchema);
-        for (const prop of model.properties.values()) {
-            if (getRenamedFrom(program, prop)) {
-                reportDisallowedDecorator(UnsupportedVersioningDecorators.RenamedFrom, prop.type);
-            }
-            if (getTypeChangedFrom(program, prop)) {
-                reportDisallowedDecorator(UnsupportedVersioningDecorators.TypeChangedFrom, prop.type);
-            }
-            if (!metadataInfo.isPayloadProperty(prop, schemaContext.visibility, schemaContext.ignoreMetadataAnnotations)) {
-                continue;
-            }
-            if (isNeverType(prop.type)) {
-                // If the property has a type of 'never', don't include it in the schema
-                continue;
-            }
-            const jsonName = getJsonName(prop);
-            const clientName = getClientName(prop);
-            const description = getDoc(program, prop);
-            // if this property is a discriminator property, remove it to keep autorestcanonical validation happy
-            if (model.baseModel) {
-                const { propertyName } = getDiscriminator(program, model.baseModel) || {};
-                if (jsonName === propertyName) {
-                    continue;
-                }
-            }
-            if (!metadataInfo.isOptional(prop, schemaContext.visibility) ||
-                prop.name === discriminator?.propertyName) {
-                if (!modelSchema.required) {
-                    modelSchema.required = [];
-                }
-                modelSchema.required.push(jsonName);
-            }
-            // Apply decorators on the property to the type's schema
-            properties[jsonName] = resolveProperty(prop, schemaContext);
-            const property = properties[jsonName];
-            if (jsonName !== clientName) {
-                property["x-ms-client-name"] = clientName;
-            }
-            if (description) {
-                property.description = description;
-            }
-            if (prop.default) {
-                property.default = getDefaultValue(prop.default);
-            }
-            if (isReadonlyProperty(program, prop)) {
-                property.readOnly = true;
-            }
-            else {
-                const vis = getVisibility(program, prop);
-                if (vis) {
-                    const mutability = [];
-                    if (vis.includes("read")) {
-                        mutability.push("read");
-                    }
-                    if (vis.includes("update")) {
-                        mutability.push("update");
-                    }
-                    if (vis.includes("create")) {
-                        mutability.push("create");
-                    }
-                    if (mutability.length > 0) {
-                        property["x-ms-mutability"] = mutability;
-                    }
-                }
-            }
-            // Attach any additional OpenAPI extensions
-            attachExtensions(prop, property);
-        }
-        // Special case: if a model type extends a single *templated* base type and
-        // has no properties of its own, absorb the definition of the base model
-        // into this schema definition.  The assumption here is that any model type
-        // defined like this is just meant to rename the underlying instance of a
-        // templated type.
-        if (model.baseModel &&
-            isTemplateDeclarationOrInstance(model.baseModel) &&
-            Object.keys(properties).length === 0) {
-            // Take the base model schema but carry across the documentation property
-            // that we set before
-            const baseSchema = getSchemaForType(model.baseModel, schemaContext);
-            Object.assign(modelSchema, baseSchema, { description: modelSchema.description });
-        }
-        else if (model.baseModel) {
-            const baseSchema = getSchemaOrRef(model.baseModel, schemaContext);
-            modelSchema.allOf = [baseSchema];
-        }
-        if (Object.keys(properties).length > 0) {
-            modelSchema.properties = properties;
-        }
-        // Attach any OpenAPI extensions
-        attachExtensions(model, modelSchema);
-        return modelSchema;
-    }
-    function canSharePropertyUsingReadonlyOrXMSMutability(prop) {
-        const sharedVisibilities = ["read", "create", "update", "write"];
-        const visibilities = getVisibility(program, prop);
-        if (visibilities) {
-            for (const visibility of visibilities) {
-                if (!sharedVisibilities.includes(visibility)) {
-                    return false;
-                }
-            }
-        }
-        return true;
-    }
-    function resolveProperty(prop, schemaContext) {
-        let propSchema;
-        if (prop.type.kind === "Enum" && prop.default) {
-            propSchema = getSchemaForEnum(prop.type);
-        }
-        else if (prop.type.kind === "Union" && prop.default) {
-            const [asEnum, _] = getUnionAsEnum(prop.type);
-            if (asEnum) {
-                propSchema = getSchemaForUnionEnum(prop.type, asEnum);
-            }
-            else {
-                propSchema = getSchemaOrRef(prop.type, schemaContext);
-            }
-        }
-        else {
-            propSchema = getSchemaOrRef(prop.type, schemaContext);
-        }
-        return applyIntrinsicDecorators(prop, propSchema);
-    }
-    function attachExtensions(type, emitObject) {
-        // Attach any OpenAPI extensions
-        const extensions = getExtensions(program, type);
-        if (getAsEmbeddingVector(program, type) !== undefined) {
-            emitObject["x-ms-embedding-vector"] = true;
-        }
-        if (extensions) {
-            for (const key of extensions.keys()) {
-                emitObject[key] = extensions.get(key);
-            }
-        }
-    }
-    // Return any string literal values for type
-    function getStringValues(type) {
-        switch (type.kind) {
-            case "String":
-                return [type.value];
-            case "Union":
-                return [...type.variants.values()].flatMap((x) => getStringValues(x.type)).filter((x) => x);
-            case "EnumMember":
-                return typeof type.value !== "number" ? [type.value ?? type.name] : [];
-            case "UnionVariant":
-                return getStringValues(type.type);
-            default:
-                return [];
-        }
-    }
-    function applyIntrinsicDecorators(typespecType, target) {
-        const newTarget = { ...target };
-        const docStr = getDoc(program, typespecType);
-        const isString = (typespecType.kind === "Scalar" || typespecType.kind === "ModelProperty") &&
-            isStringType(program, getPropertyType(typespecType));
-        const isNumeric = (typespecType.kind === "Scalar" || typespecType.kind === "ModelProperty") &&
-            isNumericType(program, getPropertyType(typespecType));
-        if (docStr) {
-            newTarget.description = docStr;
-        }
-        const formatStr = getFormat(program, typespecType);
-        if (isString && formatStr) {
-            const allowedStringFormats = [
-                "char",
-                "binary",
-                "byte",
-                "certificate",
-                "date",
-                "time",
-                "date-time",
-                "date-time-rfc1123",
-                "date-time-rfc7231",
-                "duration",
-                "password",
-                "uuid",
-                "base64url",
-                "uri",
-                "url",
-                "arm-id",
-            ];
-            if (!allowedStringFormats.includes(formatStr.toLowerCase())) {
-                reportDiagnostic(program, {
-                    code: "invalid-format",
-                    format: { schema: "string", format: formatStr },
-                    target: typespecType,
-                });
-            }
-            else {
-                newTarget.format = formatStr;
-            }
-        }
-        const pattern = getPattern(program, typespecType);
-        if (isString && pattern) {
-            newTarget.pattern = pattern;
-        }
-        const minLength = getMinLength(program, typespecType);
-        if (isString && minLength !== undefined) {
-            newTarget.minLength = minLength;
-        }
-        const maxLength = getMaxLength(program, typespecType);
-        if (isString && maxLength !== undefined) {
-            newTarget.maxLength = maxLength;
-        }
-        const minValue = getMinValue(program, typespecType);
-        if (isNumeric && minValue !== undefined) {
-            newTarget.minimum = minValue;
-        }
-        const maxValue = getMaxValue(program, typespecType);
-        if (isNumeric && maxValue !== undefined) {
-            newTarget.maximum = maxValue;
-        }
-        const minItems = getMinItems(program, typespecType);
-        if (!target.minItems && minItems !== undefined) {
-            newTarget.minItems = minItems;
-        }
-        const maxItems = getMaxItems(program, typespecType);
-        if (!target.maxItems && maxItems !== undefined) {
-            newTarget.maxItems = maxItems;
-        }
-        if (isSecret(program, typespecType)) {
-            newTarget.format = "password";
-            newTarget["x-ms-secret"] = true;
-        }
-        if (isString) {
-            const values = getKnownValues(program, typespecType);
-            if (values) {
-                const enumSchema = { ...newTarget, ...getSchemaForEnum(values) };
-                enumSchema["x-ms-enum"].modelAsString = true;
-                enumSchema["x-ms-enum"].name = getPropertyType(typespecType).name;
-                return enumSchema;
-            }
-        }
-        if (typespecType.kind === "ModelProperty" &&
-            shouldFlattenProperty(tcgcSdkContext, typespecType)) {
-            newTarget["x-ms-client-flatten"] = true;
-        }
-        attachExtensions(typespecType, newTarget);
-        return typespecType.kind === "Scalar" || typespecType.kind === "ModelProperty"
-            ? applyEncoding(typespecType, newTarget)
-            : newTarget;
-    }
-    function applyEncoding(typespecType, target) {
-        const encodeData = getEncode(program, typespecType);
-        if (encodeData) {
-            const newTarget = { ...target };
-            const newType = getSchemaForScalar(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) {
-        switch (format) {
-            case undefined:
-                return encodeAsFormat ?? encoding;
-            case "date-time":
-                switch (encoding) {
-                    case "rfc3339":
-                        return "date-time";
-                    case "unixTimestamp":
-                        return "unixtime";
-                    case "rfc7231":
-                        return "date-time-rfc7231";
-                    default:
-                        return encoding;
-                }
-            case "duration":
-                switch (encoding) {
-                    case "ISO8601":
-                        return "duration";
-                    default:
-                        return encodeAsFormat ?? encoding;
-                }
-            default:
-                return encodeAsFormat ?? encoding;
-        }
-    }
-    function applyExternalDocs(typespecType, target) {
-        const externalDocs = getExternalDocs(program, typespecType);
-        if (externalDocs) {
-            target.externalDocs = externalDocs;
-        }
-    }
-    function addXMSEnum(type, schema) {
-        if (type.node && type.node.parent && type.node.parent.kind === SyntaxKind.ModelStatement) {
-            schema["x-ms-enum"] = {
-                name: type.node.parent.id.sv,
-                modelAsString: true,
-            };
-        }
-        else if (type.kind === "String") {
-            schema["x-ms-enum"] = {
-                modelAsString: false,
-            };
-        }
-        else if (type.kind === "Enum") {
-            schema["x-ms-enum"] = {
-                name: type.name,
-                modelAsString: isFixed(program, type) ? false : true,
-            };
-            const values = [];
-            let foundCustom = false;
-            for (const member of type.members.values()) {
-                const description = getDoc(program, member);
-                values.push({
-                    name: member.name,
-                    value: member.value ?? member.name,
-                    description,
-                });
-                if (description || member.value !== undefined) {
-                    foundCustom = true;
-                }
-            }
-            if (foundCustom) {
-                schema["x-ms-enum"].values = values;
-            }
-        }
-        return schema;
-    }
-    function getSchemaForStringTemplate(stringTemplate) {
-        const [value, diagnostics] = stringTemplateToString(stringTemplate);
-        if (diagnostics.length > 0) {
-            program.reportDiagnostics(diagnostics.map((x) => ({ ...x, severity: "warning" })));
-            return { type: "string" };
-        }
-        return { type: "string", enum: [value] };
-    }
-    function getSchemaForLiterals(typespecType) {
-        switch (typespecType.kind) {
-            case "Number":
-                return { type: "number", enum: [typespecType.value] };
-            case "String":
-                return addXMSEnum(typespecType, { type: "string", enum: [typespecType.value] });
-            case "Boolean":
-                return { type: "boolean", enum: [typespecType.value] };
-            default:
-                return undefined;
-        }
-    }
-    /**
-     * If the model is an array model return the OpenAPI2Schema for the array type.
-     */
-    function getArrayType(typespecType, context) {
-        if (isArrayModelType(program, typespecType)) {
-            const array = {
-                type: "array",
-                items: getSchemaOrRef(typespecType.indexer.value, {
-                    ...context,
-                    visibility: context.visibility | Visibility.Item,
-                }),
-            };
-            if (!ifArrayItemContainsIdentifier(program, typespecType)) {
-                array["x-ms-identifiers"] = [];
-            }
-            return applyIntrinsicDecorators(typespecType, array);
-        }
-        return undefined;
-    }
-    function getSchemaForScalar(scalar) {
-        let result = {};
-        const isStd = program.checker.isStdType(scalar);
-        if (isStd) {
-            result = getSchemaForStdScalars(scalar);
-        }
-        else if (scalar.baseScalar) {
-            result = getSchemaForScalar(scalar.baseScalar);
-        }
-        const withDecorators = applyIntrinsicDecorators(scalar, result);
-        if (isStd) {
-            // Standard types are going to be inlined in the spec and we don't want the description of the scalar to show up
-            delete withDecorators.description;
-        }
-        return withDecorators;
-    }
-    function getSchemaForStdScalars(scalar) {
-        function reportNonspecificScalar(scalarName, chosenScalarName) {
-            reportDiagnostic(program, {
-                code: "nonspecific-scalar",
-                format: { type: scalarName, chosenType: chosenScalarName },
-                target: scalar,
-            });
-        }
-        switch (scalar.name) {
-            case "bytes":
-                return { type: "string", format: "byte" };
-            case "numeric":
-                reportNonspecificScalar("numeric", "int64");
-                return { type: "integer", format: "int64" };
-            case "integer":
-                reportNonspecificScalar("integer", "int64");
-                return { type: "integer", format: "int64" };
-            case "int8":
-                return { type: "integer", format: "int8" };
-            case "int16":
-                return { type: "integer", format: "int16" };
-            case "int32":
-                return { type: "integer", format: "int32" };
-            case "int64":
-                return { type: "integer", format: "int64" };
-            case "safeint":
-                return { type: "integer", format: "int64" };
-            case "uint8":
-                return { type: "integer", format: "uint8" };
-            case "uint16":
-                return { type: "integer", format: "uint16" };
-            case "uint32":
-                return { type: "integer", format: "uint32" };
-            case "uint64":
-                return { type: "integer", format: "uint64" };
-            case "float":
-                reportNonspecificScalar("float", "float64");
-                return { type: "number" };
-            case "float64":
-                return { type: "number", format: "double" };
-            case "float32":
-                return { type: "number", format: "float" };
-            case "decimal":
-                return { type: "number", format: "decimal" };
-            case "decimal128":
-                return { type: "number", format: "decimal128" };
-            case "string":
-                return { type: "string" };
-            case "boolean":
-                return { type: "boolean" };
-            case "plainDate":
-                return { type: "string", format: "date" };
-            case "utcDateTime":
-            case "offsetDateTime":
-                return { type: "string", format: "date-time" };
-            case "plainTime":
-                return { type: "string", format: "time" };
-            case "duration":
-                return { type: "string", format: "duration" };
-            case "url":
-                return { type: "string", format: "uri" };
-            default:
-                const _assertNever = scalar.name;
-                return {};
-        }
-    }
-    function processAuth(serviceNamespace) {
-        const authentication = getAuthentication(program, serviceNamespace);
-        if (authentication) {
-            return processServiceAuthentication(authentication, serviceNamespace);
-        }
-        return undefined;
-    }
-    function processServiceAuthentication(authentication, serviceNamespace) {
-        const oaiSchemes = {};
-        const security = [];
-        for (const option of authentication.options) {
-            const oai3SecurityOption = {};
-            for (const scheme of option.schemes) {
-                const result = getOpenAPI2Scheme(scheme, serviceNamespace);
-                if (result !== undefined) {
-                    const [oaiScheme, scopes] = result;
-                    oaiSchemes[scheme.id] = oaiScheme;
-                    oai3SecurityOption[scheme.id] = scopes;
-                }
-            }
-            if (Object.keys(oai3SecurityOption).length > 0) {
-                security.push(oai3SecurityOption);
-            }
-        }
-        return { securitySchemes: oaiSchemes, security };
-    }
-    function getOpenAPI2Scheme(auth, serviceNamespace) {
-        switch (auth.type) {
-            case "http":
-                if (auth.scheme !== "basic") {
-                    reportDiagnostic(program, {
-                        code: "unsupported-http-auth-scheme",
-                        target: serviceNamespace,
-                        format: { scheme: auth.scheme },
-                    });
-                    return undefined;
-                }
-                return [{ type: "basic", description: auth.description }, []];
-            case "apiKey":
-                if (auth.in === "cookie") {
-                    return undefined;
-                }
-                return [
-                    { type: "apiKey", description: auth.description, in: auth.in, name: auth.name },
-                    [],
-                ];
-            case "oauth2":
-                const flow = auth.flows[0];
-                if (flow === undefined) {
-                    return undefined;
-                }
-                const oaiFlowName = getOpenAPI2Flow(flow.type);
-                return [
-                    {
-                        type: "oauth2",
-                        description: auth.description,
-                        flow: oaiFlowName,
-                        authorizationUrl: flow.authorizationUrl,
-                        tokenUrl: flow.tokenUrl,
-                        scopes: Object.fromEntries(flow.scopes.map((x) => [x.value, x.description ?? ""])),
-                    },
-                    flow.scopes.map((x) => x.value),
-                ];
-            case "openIdConnect":
-            default:
-                reportDiagnostic(program, {
-                    code: "unsupported-auth",
-                    format: { authType: auth.type },
-                    target: currentService.type,
-                });
-                return undefined;
-        }
-    }
-    function getOpenAPI2Flow(flow) {
-        switch (flow) {
-            case "authorizationCode":
-                return "accessCode";
-            case "clientCredentials":
-                return "application";
-            case "implicit":
-                return "implicit";
-            case "password":
-                return "password";
-            default:
-                const _assertNever = flow;
-                compilerAssert(false, "Unreachable");
-        }
-    }
-}
-function prettierOutput(output) {
-    return output + "\n";
-}
-class ErrorTypeFoundError extends Error {
-    constructor() {
-        super("Error type found in evaluated TypeSpec output");
-    }
-}
-export function sortOpenAPIDocument(doc) {
-    // Doing this to make sure the classes with toJSON are resolved.
-    const unsorted = JSON.parse(JSON.stringify(doc));
-    const sorted = sortWithJsonSchema(unsorted, AutorestCanonicalOpenAPISchema, "#/$defs/AutorestCanonicalOpenAPISchema");
-    return sorted;
-}
-function resolveOutputFile(program, service, multipleServices, options, version) {
-    const azureResourceProviderFolder = options.azureResourceProviderFolder;
-    const interpolated = interpolatePath(options.outputFile, {
-        "azure-resource-provider-folder": azureResourceProviderFolder,
-        "service-name": multipleServices || azureResourceProviderFolder
-            ? getNamespaceFullName(service.type)
-            : undefined,
-        version,
-    });
-    return resolvePath(options.outputDir, interpolated);
-}
-//# sourceMappingURL=openapi.js.map