@azure-tools/typespec-autorest 0.64.0-dev.2 → 0.64.0-dev.4

package/dist/src/openapi.js

@@ -1,5 +1,5 @@
 import { FinalStateValue, extractLroStates, getArmResourceIdentifierConfig, getAsEmbeddingVector, getLroMetadata, getUnionAsEnum, hasUniqueItems, } from "@azure-tools/typespec-azure-core";
-import { getArmCommonTypeOpenAPIRef, getArmIdentifiers, getArmKeyIdentifiers, getCustomResourceOptions, getExternalTypeRef, getInlineAzureType, isArmCommonType, isArmExternalType, isArmProviderNamespace, isAzureResource, } from "@azure-tools/typespec-azure-resource-manager";
+import { getArmCommonTypeOpenAPIRef, getArmIdentifiers, getArmKeyIdentifiers, getCustomResourceOptions, getExternalTypeRef, getFeature, getInlineAzureType, getResourceFeatureSet, isArmCommonType, isArmExternalType, isArmProviderNamespace, isAzureResource, } from "@azure-tools/typespec-azure-resource-manager";
 import { getClientDefaultValue, getClientNameOverride, getLegacyHierarchyBuilding, getMarkAsLro, shouldFlattenProperty, } from "@azure-tools/typespec-client-generator-core";
 import { NoTarget, compilerAssert, createDiagnosticCollector, explainStringTemplateNotSerializable, getAllTags, getAnyExtensionFromPath, getDirectoryPath, getDiscriminator, getDoc, getEncode, getFormat, getLifecycleVisibilityEnum, getMaxItems, getMaxLength, getMaxValue, getMinItems, getMinLength, getMinValue, getNamespaceFullName, getPagingOperation, getPattern, getProperty, getRelativePathFromDirectory, getRootLength, getSummary, getVisibilityForClass, ignoreDiagnostics, interpolatePath, isArrayModelType, isDeprecated, isErrorModel, isErrorType, isGlobalNamespace, isList, isNeverType, isNullType, isNumeric, isRecordModelType, isSecret, isService, isTemplateDeclaration, isTemplateDeclarationOrInstance, isVoidType, joinPaths, navigateTypesInNamespace, normalizePath, reportDeprecated, resolveEncodedName, resolvePath, serializeValueAsJson, } from "@typespec/compiler";
 import { SyntaxKind } from "@typespec/compiler/ast";
@@ -12,22 +12,12 @@ import { AutorestOpenAPISchema } from "./autorest-openapi-schema.js";
 import { getExamples, getRef } from "./decorators.js";
 import { sortWithJsonSchema } from "./json-schema-sorter/sorter.js";
 import { createDiagnostic, reportDiagnostic } from "./lib.js";
+import { LateBoundReference, } from "./types.js";
 import { getClientName, isSupportedAutorestFormat, resolveOperationId, } from "./utils.js";
 import { resolveXmlModule } from "./xml.js";
-/**
- * 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;
-    }
-}
 export async function getOpenAPIForService(context, options) {
     const { program, service } = context;
+    const proxy = context.proxy ?? createDefaultDocumentProxy(program, service, options, context.version);
     const typeNameOptions = {
         // shorten type names by removing TypeSpec and service namespace
         namespaceFilter(ns) {
@@ -35,31 +25,15 @@ export async function getOpenAPIForService(context, options) {
         },
     };
     const httpService = ignoreDiagnostics(getHttpService(program, service.type));
-    const info = resolveInfo(program, service.type);
+    proxy.addAdditionalInfo(resolveInfo(program, service.type));
     const auth = processAuth(service.type);
+    if (auth?.securitySchemes)
+        proxy.addSecuritySchemes(auth.securitySchemes);
+    if (auth?.security)
+        proxy.addSecurityRequirements(auth.security);
     const xml = await resolveXmlModule();
     const xmlStrategy = options.xmlStrategy;
-    const root = {
-        swagger: "2.0",
-        info: {
-            title: "(title)",
-            ...info,
-            version: context.version ?? info?.version ?? "0000-00-00",
-            "x-typespec-generated": [{ emitter: "@azure-tools/typespec-autorest" }],
-        },
-        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: {},
-    };
+    proxy.addHostInfo(resolveHost(program, service.type));
     let currentEndpoint;
     let currentConsumes;
     let currentProduces;
@@ -84,8 +58,6 @@ export async function getOpenAPIForService(context, options) {
     // - Models that have had properties spread into parameters.
     // - Multipart models
     const indirectlyProcessedTypes = new Set();
-    // De-dupe the per-endpoint tags that will be added into the #/tags
-    const tags = new Set();
     const operationIdsWithExample = new Set();
     const [exampleMap, diagnostics] = await loadExamples(program, options, context.version);
     program.reportDiagnostics(diagnostics);
@@ -120,45 +92,10 @@ export async function getOpenAPIForService(context, options) {
     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"];
-    }
-    return {
-        document: root,
-        operationExamples: [...operationIdsWithExample]
-            .map((operationId) => {
-            const data = exampleMap.get(operationId);
-            if (data) {
-                return { operationId, examples: Object.values(data) };
-            }
-            else {
-                return undefined;
-            }
-        })
-            .filter((x) => x),
-        outputFile: context.outputFile,
-    };
+    proxy.setGlobalConsumes([...globalConsumes]);
+    proxy.setGlobalProduces([...globalProduces]);
+    proxy.writeExamples(exampleMap, operationIdsWithExample);
+    return proxy.resolveDocuments(context);
     function resolveHost(program, namespace) {
         const servers = getServers(program, namespace);
         if (servers === undefined) {
@@ -238,13 +175,6 @@ export async function getOpenAPIForService(context, options) {
         }
         return undefined;
     }
-    function requiresXMsPaths(path, operation) {
-        const isShared = isSharedRoute(program, operation) ?? false;
-        if (path.includes("?")) {
-            return true;
-        }
-        return isShared;
-    }
     function getFinalStateVia(metadata) {
         switch (metadata.finalStateVia) {
             case FinalStateValue.azureAsyncOperation:
@@ -265,66 +195,40 @@ export async function getOpenAPIForService(context, options) {
             metadata.finalResult.name.length > 0) {
             const model = metadata.finalResult;
             const schemaOrRef = resolveExternalRef(metadata.finalResult);
+            let overrideName = undefined;
+            if (model.kind === "Model" && isArrayModelType(program, model)) {
+                const itemType = getModelOrScalarTypeIfNullable(model.indexer?.value);
+                if (itemType?.kind === "Model" && itemType.name.length > 0) {
+                    overrideName = (n, v) => `${n.replaceAll(/[[\]]/g, "")}${getVisibilitySuffix(v, Visibility.Read)}Array`;
+                }
+            }
             if (schemaOrRef !== undefined) {
-                const ref = new Ref();
-                ref.value = schemaOrRef.$ref;
+                const ref = proxy.createExternalRef(schemaOrRef.$ref);
                 return { "final-state-schema": ref };
             }
             const pending = pendingSchemas.getOrAdd(metadata.finalResult, Visibility.Read, () => ({
                 type: model,
                 visibility: Visibility.Read,
-                ref: refs.getOrAdd(model, Visibility.Read, () => new Ref()),
+                getSchemaNameOverride: overrideName,
+                ref: refs.getOrAdd(model, Visibility.Read, () => proxy.createLocalRef(model)),
             }));
             return { "final-state-schema": pending.ref };
         }
         return undefined;
     }
-    /** Initialize the openapi PathItem object where this operation should be added. */
-    function initPathItem(operation) {
-        let { path, operation: op, verb } = operation;
-        let pathsObject = root.paths;
-        if (root.paths[path]?.[verb] === undefined && !path.includes("?")) {
-            pathsObject = root.paths;
-        }
-        else if (requiresXMsPaths(path, op)) {
-            // if the key already exists in x-ms-paths, append the operation id.
-            if (path.includes("?")) {
-                if (root["x-ms-paths"]?.[path] !== undefined) {
-                    path += `&_overload=${operation.operation.name}`;
-                }
-            }
-            else {
-                path += `?_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 "${path}". This is unexpected.`);
-        }
-        if (!pathsObject[path]) {
-            pathsObject[path] = {};
-        }
-        return pathsObject[path];
-    }
     function emitOperation(operation) {
         const { operation: op, verb, parameters } = operation;
-        const currentPath = initPathItem(operation);
-        if (!currentPath[verb]) {
-            currentPath[verb] = {};
-        }
-        currentEndpoint = currentPath[verb];
+        currentEndpoint = proxy.createOrGetEndpoint(operation, context);
         currentConsumes = new Set();
         currentProduces = new Set();
         const currentTags = getAllTags(program, op);
         if (currentTags) {
-            currentEndpoint.tags = currentTags;
+            currentEndpoint.tags = [...currentTags.values()];
             for (const tag of currentTags) {
                 // Add to root tags if not already there
-                tags.add(tag);
+                proxy.addTag(tag, op);
             }
         }
-        currentEndpoint.operationId = resolveOperationId(context, op);
         applyExternalDocs(op, currentEndpoint);
         // Set up basic endpoint fields
         currentEndpoint.summary = getSummary(program, op);
@@ -637,7 +541,7 @@ export async function getOpenAPIForService(context, options) {
             const pending = pendingSchemas.getOrAdd(type, schemaContext.visibility, () => ({
                 type,
                 visibility: schemaContext.visibility,
-                ref: refs.getOrAdd(type, schemaContext.visibility, () => new Ref()),
+                ref: refs.getOrAdd(type, schemaContext.visibility, () => proxy.createLocalRef(type)),
                 getSchemaNameOverride: schemaNameOverride,
             }));
             return { $ref: pending.ref };
@@ -1022,8 +926,8 @@ export async function getOpenAPIForService(context, options) {
             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 key = getParameterKey(program, property, param, proxy.getParameterMap(), typeNameOptions);
+            proxy.writeParameter(key, property, param);
             const refedParam = param;
             for (const key of Object.keys(param)) {
                 delete refedParam[key];
@@ -1052,12 +956,12 @@ export async function getOpenAPIForService(context, options) {
                 else if (group.size > 1) {
                     name += getVisibilitySuffix(visibility, Visibility.Read);
                 }
-                checkDuplicateTypeName(program, processed.type, name, root.definitions);
-                processed.ref.value = "#/definitions/" + encodeURIComponent(name);
+                checkDuplicateTypeName(program, processed.type, name, proxy.getDefinitionMap());
+                processed.ref.setLocalValue(program, encodeURIComponent(name), processed.type);
                 if (processed.schema) {
                     if (shouldEmitXml)
                         attachXml(processed.type, name, processed);
-                    root.definitions[name] = processed.schema;
+                    proxy.writeDefinition(name, processed, processed.schema);
                 }
             }
         }
@@ -1114,11 +1018,6 @@ export async function getOpenAPIForService(context, options) {
         }
         return false;
     }
-    function emitTags() {
-        for (const tag of tags) {
-            root.tags.push({ name: tag });
-        }
-    }
     function getSchemaForType(type, schemaContext, namespace) {
         const builtinType = getSchemaForLiterals(type);
         if (builtinType !== undefined) {
@@ -2204,4 +2103,394 @@ async function loadExamples(program, options, version) {
 function isHttpParameterProperty(httpProperty) {
     return ["header", "query", "path", "cookie"].includes(httpProperty.kind);
 }
+export function createDocumentProxy(program, service, options, version) {
+    const features = getResourceFeatureSet(program, service.type);
+    if (options.outputSplitting === undefined ||
+        options.outputSplitting !== "legacy-feature-files" ||
+        features === undefined ||
+        features.size < 2) {
+        return createDefaultDocumentProxy(program, service, options, version);
+    }
+    else {
+        return createFeatureDocumentProxy(program, service, options, version);
+    }
+}
+export function createDefaultDocumentProxy(program, service, options, version) {
+    const root = initializeOpenApi2Document(program, service, version);
+    const tags = new Set();
+    const definitions = new Map();
+    const parameters = new Map();
+    let examples = new Map();
+    let operationIdsWithExamples = new Set();
+    return {
+        getDefinitionMap() {
+            const result = {};
+            for (const [name, schema] of definitions) {
+                result[name] = schema;
+            }
+            return result;
+        },
+        writeDefinition: (name, processed, schema) => {
+            definitions.set(name, schema);
+        },
+        getParameterMap() {
+            const result = {};
+            for (const [name, [_, parameter]] of parameters) {
+                result[name] = parameter;
+            }
+            return result;
+        },
+        writeParameter(key, prop, parameter) {
+            parameters.set(key, [prop, parameter]);
+            let defaultParameters = root.parameters;
+            if (defaultParameters === undefined) {
+                defaultParameters = {};
+                root.parameters = defaultParameters;
+            }
+            defaultParameters[key] = { ...parameter };
+        },
+        createOrGetEndpoint(op, context) {
+            const pathItem = initPathItem(program, op, root);
+            if (!pathItem[op.verb]) {
+                pathItem[op.verb] = { parameters: [] };
+            }
+            const resolvedOp = pathItem[op.verb];
+            resolvedOp.operationId = resolveOperationId(context, op.operation);
+            return resolvedOp;
+        },
+        addTag(tag, op) {
+            tags.add(tag);
+        },
+        setGlobalConsumes(consumes) {
+            root.consumes = consumes;
+        },
+        setGlobalProduces(produces) {
+            root.produces = produces;
+        },
+        addAdditionalInfo(info) {
+            if (info !== undefined) {
+                Object.assign(root.info, info);
+            }
+        },
+        addHostInfo(hostInfo) {
+            Object.assign(root, hostInfo);
+        },
+        addSecurityRequirements(requirements) {
+            if (requirements !== undefined && requirements.length > 0) {
+                root.security = requirements;
+            }
+        },
+        addSecuritySchemes(schemes) {
+            if (schemes !== undefined && Object.keys(schemes).length > 0) {
+                root.securityDefinitions = schemes;
+            }
+        },
+        writeExamples(inExamples, exampleIds) {
+            examples = inExamples;
+            operationIdsWithExamples = exampleIds;
+        },
+        resolveDocuments(context) {
+            root.definitions = {};
+            for (const [name, schema] of definitions) {
+                root.definitions[name] = schema;
+            }
+            finalizeOpenApi2Document(root, tags);
+            return Promise.resolve([
+                {
+                    document: root,
+                    operationExamples: [...operationIdsWithExamples]
+                        .map((operationId) => {
+                        const data = examples.get(operationId);
+                        if (data) {
+                            return { operationId, examples: Object.values(data) };
+                        }
+                        else {
+                            return undefined;
+                        }
+                    })
+                        .filter((x) => x),
+                    outputFile: context.outputFile,
+                    context: context,
+                },
+            ]);
+        },
+        createLocalRef(type) {
+            const feature = getFeature(program, type);
+            const result = new LateBoundReference();
+            result.file = feature.fileName;
+            return result;
+        },
+        createExternalRef(absoluteRef) {
+            const result = new LateBoundReference();
+            result.setRemoteValue(absoluteRef);
+            return result;
+        },
+        getCurrentFeature() {
+            return undefined;
+        },
+        setCurrentFeature(feature) {
+            return;
+        },
+        getParameterRef(key) {
+            return `#/parameters/${encodeURIComponent(key)}`;
+        },
+    };
+}
+function createFeatureDocumentProxy(program, service, options, version) {
+    const features = getResourceFeatureSet(program, service.type);
+    if (features === undefined || features.size < 2)
+        return createDefaultDocumentProxy(program, service, options, version);
+    const root = new Map();
+    const operationFeatures = new Map();
+    let examples = new Map();
+    let operationIdsWithExamples = new Set();
+    for (const featureName of features.keys()) {
+        const featureOptions = features.get(featureName);
+        root.set(featureName.toLowerCase(), initializeOpenAPIDocumentItem(program, service, featureOptions, version));
+    }
+    const defaultFeature = [...root.entries()].filter(([key, _]) => key.toLowerCase() === "common")[0][1];
+    const definitions = new Map();
+    const resolvedParameters = new Map();
+    let currentFeature = "";
+    return {
+        getDefinitionMap() {
+            const result = {};
+            for (const [name, [_, schema]] of definitions) {
+                result[name] = schema;
+            }
+            return result;
+        },
+        writeDefinition: (name, processed, schema) => {
+            const feature = getFeatureKey(program, processed.type);
+            definitions.set(name, [feature, schema]);
+        },
+        getParameterMap() {
+            const result = {};
+            for (const [name, [_, parameter]] of resolvedParameters) {
+                result[name] = parameter;
+            }
+            return result;
+        },
+        writeParameter(key, prop, parameter) {
+            resolvedParameters.set(key, [prop, parameter]);
+            let defaultParameters = defaultFeature.document.parameters;
+            if (defaultParameters === undefined) {
+                defaultParameters = {};
+                defaultFeature.document.parameters = defaultParameters;
+            }
+            defaultParameters[key] = { ...parameter };
+        },
+        createOrGetEndpoint(op, context) {
+            const options = getFeature(program, op.operation);
+            const item = root.get(options.featureName.toLowerCase());
+            const pathItem = initPathItem(program, op, item.document);
+            if (!pathItem[op.verb]) {
+                pathItem[op.verb] = { parameters: [] };
+            }
+            const resolvedOp = pathItem[op.verb];
+            const opId = resolveOperationId(context, op.operation);
+            addFeatureOperation(opId, options.featureName);
+            resolvedOp.operationId = opId;
+            return resolvedOp;
+        },
+        setGlobalConsumes(mimeTypes) {
+            for (const featureItem of root.values()) {
+                featureItem.document.consumes = [];
+                for (const mimeType of mimeTypes) {
+                    featureItem.document.consumes.push(mimeType);
+                }
+            }
+        },
+        setGlobalProduces(mimeTypes) {
+            for (const featureItem of root.values()) {
+                featureItem.document.produces = [];
+                for (const mimeType of mimeTypes) {
+                    featureItem.document.produces.push(mimeType);
+                }
+            }
+        },
+        addTag(tag, op) {
+            const feature = getFeatureKey(program, op);
+            const item = root.get(feature);
+            item.tags.add(tag);
+        },
+        addAdditionalInfo(info) {
+            if (info !== undefined) {
+                for (const featureItem of root.values())
+                    Object.assign(featureItem.document.info, info);
+            }
+        },
+        addHostInfo(hostInfo) {
+            for (const featureItem of root.values())
+                Object.assign(featureItem.document, hostInfo);
+        },
+        addSecurityRequirements(requirements) {
+            if (requirements !== undefined && requirements.length > 0) {
+                for (const featureItem of root.values())
+                    featureItem.document.security = requirements;
+            }
+        },
+        addSecuritySchemes(schemes) {
+            if (schemes !== undefined && Object.keys(schemes).length > 0) {
+                for (const featureItem of root.values())
+                    featureItem.document.securityDefinitions = schemes;
+            }
+        },
+        writeExamples(inExamples, exampleIds) {
+            examples = inExamples;
+            operationIdsWithExamples = exampleIds;
+        },
+        resolveDocuments(context) {
+            const docs = [];
+            for (const [featureName, featureItem] of root.entries()) {
+                const exampleIds = operationFeatures.get(featureName) || new Set();
+                const featureExamples = [...exampleIds]
+                    .filter((id) => operationIdsWithExamples.has(id))
+                    .map((operationId) => {
+                    const data = examples.get(operationId);
+                    if (data) {
+                        return { operationId, examples: Object.values(data) };
+                    }
+                    else {
+                        return undefined;
+                    }
+                })
+                    .filter((x) => x);
+                const definitionsForFeature = Array.from(definitions.entries()).filter(([_, [definitionFeature, __]]) => definitionFeature === featureName);
+                featureItem.document.definitions = {};
+                for (const [defName, [_, defSchema]] of definitionsForFeature) {
+                    featureItem.document.definitions[defName] = defSchema;
+                }
+                finalizeOpenApi2Document(featureItem.document, featureItem.tags);
+                docs.push({
+                    document: featureItem.document,
+                    operationExamples: featureExamples,
+                    outputFile: context.outputFile,
+                    feature: featureItem.options.fileName,
+                    context: context,
+                });
+            }
+            // Collect operation examples for this feature
+            return Promise.resolve(docs);
+        },
+        createLocalRef(type) {
+            const feature = getFeature(program, type);
+            currentFeature = feature.featureName;
+            const result = new LateBoundReference();
+            result.useFeatures = true;
+            result.file = feature.fileName;
+            result.getFileContext = () => this.getCurrentFeature();
+            return result;
+        },
+        createExternalRef(absoluteRef) {
+            const result = new LateBoundReference();
+            result.setRemoteValue(absoluteRef);
+            return result;
+        },
+        getCurrentFeature() {
+            return currentFeature;
+        },
+        setCurrentFeature(feature) {
+            currentFeature = feature;
+        },
+        getParameterRef(key) {
+            return `./common.json/parameters/${encodeURIComponent(key)}`;
+        },
+    };
+    function getFeatureKey(program, type) {
+        const feature = getFeature(program, type);
+        return feature.featureName.toLowerCase();
+    }
+    function addFeatureOperation(operationId, featureName) {
+        featureName = featureName.toLowerCase();
+        if (!operationFeatures.has(featureName)) {
+            operationFeatures.set(featureName, new Set([operationId]));
+            return;
+        }
+        const ops = operationFeatures.get(featureName);
+        ops.add(operationId);
+    }
+}
+function initializeOpenAPIDocumentItem(program, service, options, version) {
+    return {
+        document: initializeOpenApi2Document(program, service, version),
+        operationExamples: new Map(),
+        tags: new Set(),
+        options,
+    };
+}
+function initializeOpenApi2Document(program, service, version) {
+    return {
+        swagger: "2.0",
+        info: {
+            title: "(title)",
+            version: version ?? "0000-00-00",
+            "x-typespec-generated": [{ emitter: "@azure-tools/typespec-autorest" }],
+        },
+        schemes: ["https"],
+        externalDocs: getExternalDocs(program, service.type),
+        produces: [], // Pre-initialize produces and consumes so that
+        consumes: [], // they show up at the top of the document
+        tags: [],
+        paths: {},
+        "x-ms-paths": {},
+        definitions: {},
+        parameters: {},
+    };
+}
+function finalizeOpenApi2Document(root, tags) {
+    const xMsPaths = root["x-ms-paths"];
+    if (xMsPaths && Object.keys(xMsPaths).length === 0) {
+        delete root["x-ms-paths"];
+    }
+    const rootSecurity = root.security;
+    if (rootSecurity && Object.keys(rootSecurity).length === 0) {
+        delete root.security;
+    }
+    const securityDefs = root.securityDefinitions;
+    if (securityDefs && Object.keys(securityDefs).length === 0) {
+        delete root.securityDefinitions;
+    }
+    if (root.consumes !== undefined && root.consumes.length === 0) {
+        delete root.consumes;
+    }
+    if (root.produces !== undefined && root.produces.length === 0) {
+        delete root.produces;
+    }
+    root.tags = Array.from(tags).map((tagName) => ({ name: tagName }));
+}
+function initPathItem(program, operation, root) {
+    let { path, operation: op, verb } = operation;
+    let pathsObject = root.paths;
+    if (root.paths[path]?.[verb] === undefined && !path.includes("?")) {
+        pathsObject = root.paths;
+    }
+    else if (requiresXMsPaths(program, path, op)) {
+        // if the key already exists in x-ms-paths, append the operation id.
+        if (path.includes("?")) {
+            if (root["x-ms-paths"]?.[path] !== undefined) {
+                path += `&_overload=${operation.operation.name}`;
+            }
+        }
+        else {
+            path += `?_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 "${path}". This is unexpected.`);
+    }
+    if (!pathsObject[path]) {
+        pathsObject[path] = {};
+    }
+    return pathsObject[path];
+}
+function requiresXMsPaths(program, path, operation) {
+    const isShared = isSharedRoute(program, operation) ?? false;
+    if (path.includes("?")) {
+        return true;
+    }
+    return isShared;
+}
 //# sourceMappingURL=openapi.js.map