@scalar/postman-to-openapi 0.5.2 → 0.6.0

package/dist/helpers/logo.js

@@ -1,23 +1,24 @@
-function processLogo(postmanCollection) {
-  const logoVariables = postmanCollection.variable?.filter((v) => v.key?.startsWith("x-logo.")) || [];
-  if (logoVariables.length === 0) {
-    return null;
-  }
-  const logo = {};
-  logoVariables.forEach((v) => {
-    if (v.key) {
-      const key = v.key.replace("x-logo.", "").replace("Var", "");
-      logo[key] = v.value;
+/**
+ * Processes logo information from a Postman Collection.
+ * This function extracts logo-related variables from the collection
+ * and constructs an object with logo properties.
+ */
+export function processLogo(postmanCollection) {
+    const logoVariables = postmanCollection.variable?.filter((v) => v.key?.startsWith('x-logo.')) || [];
+    if (logoVariables.length === 0) {
+        return null;
     }
-  });
-  return {
-    url: logo.url,
-    backgroundColor: logo.backgroundColor,
-    altText: logo.altText,
-    href: logo.href
-  };
+    const logo = {};
+    logoVariables.forEach((v) => {
+        if (v.key) {
+            const key = v.key.replace('x-logo.', '').replace('Var', '');
+            logo[key] = v.value;
+        }
+    });
+    return {
+        url: logo.url,
+        backgroundColor: logo.backgroundColor,
+        altText: logo.altText,
+        href: logo.href,
+    };
 }
-export {
-  processLogo
-};
-//# sourceMappingURL=logo.js.map

package/dist/helpers/markdown.js

@@ -1,32 +1,35 @@
-const supHeaders = ["object", "name", "description", "example", "type", "required"];
-function parseMdTable(md) {
-  const lines = md.split("\n").filter((line) => line.trim() !== "");
-  if (typeof lines[0] === "undefined" || lines.length < 3) {
-    return {};
-  }
-  const header = lines[0].split("|").map((cell) => cell.trim()).filter(Boolean);
-  if (!header.includes("object") || !header.includes("name")) {
-    return {};
-  }
-  const headers = header.map((h) => supHeaders.includes(h) ? h : false);
-  const rows = lines.slice(2).map(
-    (line) => line.split("|").map((cell) => cell.trim()).filter(Boolean)
-  );
-  const tableObj = rows.reduce((accTable, cell) => {
-    const cellObj = cell.reduce((accCell, field, index) => {
-      if (headers[index] && typeof headers[index] === "string") {
-        accCell[headers[index]] = field;
-      }
-      return accCell;
-    }, {});
-    if (cellObj.name) {
-      accTable[cellObj.name] = cellObj;
+const supHeaders = ['object', 'name', 'description', 'example', 'type', 'required'];
+/**
+ * Parses a Markdown table and returns an object representation.
+ */
+export function parseMdTable(md) {
+    const lines = md.split('\n').filter((line) => line.trim() !== '');
+    if (typeof lines[0] === 'undefined' || lines.length < 3) {
+        return {};
+    }
+    const header = lines[0]
+        .split('|')
+        .map((cell) => cell.trim())
+        .filter(Boolean);
+    if (!header.includes('object') || !header.includes('name')) {
+        return {};
     }
-    return accTable;
-  }, {});
-  return tableObj;
+    const headers = header.map((h) => (supHeaders.includes(h) ? h : false));
+    const rows = lines.slice(2).map((line) => line
+        .split('|')
+        .map((cell) => cell.trim())
+        .filter(Boolean));
+    const tableObj = rows.reduce((accTable, cell) => {
+        const cellObj = cell.reduce((accCell, field, index) => {
+            if (headers[index] && typeof headers[index] === 'string') {
+                accCell[headers[index]] = field;
+            }
+            return accCell;
+        }, {});
+        if (cellObj.name) {
+            accTable[cellObj.name] = cellObj;
+        }
+        return accTable;
+    }, {});
+    return tableObj;
 }
-export {
-  parseMdTable
-};
-//# sourceMappingURL=markdown.js.map

package/dist/helpers/merge-operation.d.ts

@@ -0,0 +1,55 @@
+import type { OpenAPIV3_1 } from '@scalar/openapi-types';
+/**
+ * Merges two OpenAPI OperationObject instances.
+ * Assumes that all example names (keys in the 'examples' objects) are unique across both operations.
+ * This assumption allows us to shallowly merge example maps without risk of overwriting.
+ *
+ * @example
+ * const op1: OpenAPIV3_1.OperationObject = {
+ *   tags: ['user'],
+ *   parameters: [
+ *     {
+ *       name: 'id',
+ *       in: 'path',
+ *       required: true,
+ *       schema: { type: 'string' },
+ *       examples: { A: { value: 1 } }
+ *     }
+ *   ],
+ *   requestBody: {
+ *     content: {
+ *       'application/json': {
+ *         examples: { example1: { value: { foo: 'bar' } } }
+ *       }
+ *     }
+ *   }
+ * }
+ *
+ * const op2: OpenAPIV3_1.OperationObject = {
+ *   tags: ['admin'],
+ *   parameters: [
+ *     {
+ *       name: 'id',
+ *       in: 'path',
+ *       required: true,
+ *       schema: { type: 'string' },
+ *       examples: { B: { value: 2 } }
+ *     }
+ *   ],
+ *   requestBody: {
+ *     content: {
+ *       'application/json': {
+ *         examples: { example2: { value: { hello: 'world' } } }
+ *       }
+ *     }
+ *   }
+ * }
+ *
+ * const merged = mergeOperations(op1, op2)
+ * // merged.tags -> ['user', 'admin']
+ * // merged.parameters[0].examples -> { B: { value: 2 }, A: { value: 1 } }
+ * // merged.requestBody.content['application/json'].examples ->
+ * //    { example2: {...}, example1: {...} }
+ */
+export declare const mergeOperations: (operation1: OpenAPIV3_1.OperationObject, operation2: OpenAPIV3_1.OperationObject) => OpenAPIV3_1.OperationObject;
+//# sourceMappingURL=merge-operation.d.ts.map

package/dist/helpers/merge-operation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-operation.d.ts","sourceRoot":"","sources":["../../src/helpers/merge-operation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,eAAO,MAAM,eAAe,GAC1B,YAAY,WAAW,CAAC,eAAe,EACvC,YAAY,WAAW,CAAC,eAAe,KACtC,WAAW,CAAC,eAiFd,CAAA"}

package/dist/helpers/merge-operation.js

@@ -0,0 +1,125 @@
+/**
+ * Merges two OpenAPI OperationObject instances.
+ * Assumes that all example names (keys in the 'examples' objects) are unique across both operations.
+ * This assumption allows us to shallowly merge example maps without risk of overwriting.
+ *
+ * @example
+ * const op1: OpenAPIV3_1.OperationObject = {
+ *   tags: ['user'],
+ *   parameters: [
+ *     {
+ *       name: 'id',
+ *       in: 'path',
+ *       required: true,
+ *       schema: { type: 'string' },
+ *       examples: { A: { value: 1 } }
+ *     }
+ *   ],
+ *   requestBody: {
+ *     content: {
+ *       'application/json': {
+ *         examples: { example1: { value: { foo: 'bar' } } }
+ *       }
+ *     }
+ *   }
+ * }
+ *
+ * const op2: OpenAPIV3_1.OperationObject = {
+ *   tags: ['admin'],
+ *   parameters: [
+ *     {
+ *       name: 'id',
+ *       in: 'path',
+ *       required: true,
+ *       schema: { type: 'string' },
+ *       examples: { B: { value: 2 } }
+ *     }
+ *   ],
+ *   requestBody: {
+ *     content: {
+ *       'application/json': {
+ *         examples: { example2: { value: { hello: 'world' } } }
+ *       }
+ *     }
+ *   }
+ * }
+ *
+ * const merged = mergeOperations(op1, op2)
+ * // merged.tags -> ['user', 'admin']
+ * // merged.parameters[0].examples -> { B: { value: 2 }, A: { value: 1 } }
+ * // merged.requestBody.content['application/json'].examples ->
+ * //    { example2: {...}, example1: {...} }
+ */
+export const mergeOperations = (operation1, operation2) => {
+    const operation = { ...operation2 };
+    // Merge tags (union, preserving uniqueness)
+    if (operation1.tags || operation.tags) {
+        operation.tags = Array.from(new Set([...(operation1.tags ?? []), ...(operation.tags ?? [])]));
+    }
+    const parameters = new Map();
+    const generateParameterId = (param) => `${param.name}/${param.in}`;
+    // Seed parameter list from operation2 (the base)
+    if (operation.parameters) {
+        for (const parameter of operation.parameters) {
+            const id = generateParameterId(parameter);
+            parameters.set(id, parameter);
+        }
+    }
+    // Merge parameters from operation1 into parameters of operation2.
+    // For each parameter, merge their 'examples' objects, assuming example keys are unique.
+    if (operation1.parameters) {
+        for (const parameter of operation1.parameters) {
+            const id = generateParameterId(parameter);
+            if (parameters.has(id)) {
+                const existingParameter = parameters.get(id);
+                if (existingParameter) {
+                    // Example keys are expected to be unique, so shallow merge is safe.
+                    existingParameter.examples = {
+                        ...existingParameter.examples,
+                        ...parameter.examples,
+                    };
+                }
+            }
+            else {
+                parameters.set(id, parameter);
+            }
+        }
+    }
+    if (parameters.size > 0) {
+        operation.parameters = Array.from(parameters.values());
+    }
+    const contentMediaTypeMap = new Map();
+    // Seed requestBody content from operation2 (the base)
+    if (operation.requestBody?.content) {
+        for (const [contentType, mediaType] of Object.entries(operation.requestBody.content)) {
+            contentMediaTypeMap.set(contentType, mediaType);
+        }
+    }
+    // Merge requestBody content from operation1 into the base.
+    // When merging 'examples', we expect example names to be unique (no overwrite).
+    if (operation1.requestBody?.content) {
+        for (const [contentType, mediaType] of Object.entries(operation1.requestBody.content)) {
+            const mediaTypeObj = mediaType;
+            if (contentMediaTypeMap.has(contentType)) {
+                const existingMediaType = contentMediaTypeMap.get(contentType);
+                if (existingMediaType && (existingMediaType.examples || mediaTypeObj.examples)) {
+                    // Assumption: example names (keys) are unique, so this merge is safe
+                    existingMediaType.examples = {
+                        ...existingMediaType.examples,
+                        ...mediaTypeObj.examples,
+                    };
+                }
+            }
+            else {
+                contentMediaTypeMap.set(contentType, mediaTypeObj);
+            }
+        }
+    }
+    if (contentMediaTypeMap.size > 0) {
+        operation.requestBody = {
+            ...operation.requestBody,
+            content: Object.fromEntries(contentMediaTypeMap),
+        };
+    }
+    return operation;
+};

package/dist/helpers/merge-path-item.d.ts

@@ -0,0 +1,5 @@
+import type { OpenAPIV3_1 } from '@scalar/openapi-types';
+export declare const DEFAULT_EXAMPLE_NAME = "Default example";
+export declare const OPERATION_KEYS: readonly (keyof OpenAPIV3_1.PathItemObject)[];
+export declare const mergePathItem: (paths: OpenAPIV3_1.PathsObject, normalizedPathKey: string, pathItem: OpenAPIV3_1.PathItemObject, mergeOperation?: boolean) => void;
+//# sourceMappingURL=merge-path-item.d.ts.map

package/dist/helpers/merge-path-item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-path-item.d.ts","sourceRoot":"","sources":["../../src/helpers/merge-path-item.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAOxD,eAAO,MAAM,oBAAoB,oBAAoB,CAAA;AAErD,eAAO,MAAM,cAAc,EAAE,SAAS,CAAC,MAAM,WAAW,CAAC,cAAc,CAAC,EASvE,CAAA;AAED,eAAO,MAAM,aAAa,GACxB,OAAO,WAAW,CAAC,WAAW,EAC9B,mBAAmB,MAAM,EACzB,UAAU,WAAW,CAAC,cAAc,EACpC,iBAAgB,OAAe,KAC9B,IA8BF,CAAA"}

package/dist/helpers/merge-path-item.js

@@ -0,0 +1,37 @@
+import { generateUniqueValue } from '../helpers/generate-unique-value.js';
+import { getOperationExamples } from '../helpers/get-operation-examples.js';
+import { mergeOperations } from '../helpers/merge-operation.js';
+import { renameOperationExamples } from '../helpers/rename-operation-example.js';
+export const DEFAULT_EXAMPLE_NAME = 'Default example';
+export const OPERATION_KEYS = [
+    'get',
+    'put',
+    'post',
+    'delete',
+    'options',
+    'head',
+    'patch',
+    'trace',
+];
+export const mergePathItem = (paths, normalizedPathKey, pathItem, mergeOperation = false) => {
+    const targetPath = (paths[normalizedPathKey] ?? {});
+    for (const [key, value] of Object.entries(pathItem)) {
+        if (value === undefined) {
+            continue;
+        }
+        const isOperationKey = OPERATION_KEYS.includes(key);
+        if (isOperationKey && targetPath[key] && mergeOperation) {
+            // Get all example names from the target path
+            const exampleNames = getOperationExamples(targetPath);
+            // Generate a unique example name
+            const newExampleName = generateUniqueValue(DEFAULT_EXAMPLE_NAME, (value) => !exampleNames.has(value), '#');
+            // Rename operation examples from the new path item (we know it's gonna have only the default example)
+            renameOperationExamples(pathItem[key], DEFAULT_EXAMPLE_NAME, newExampleName);
+            // Merge the operations
+            targetPath[key] = mergeOperations(targetPath[key], pathItem[key]);
+            continue;
+        }
+        targetPath[key] = value;
+    }
+    paths[normalizedPathKey] = targetPath;
+};

package/dist/helpers/parameters.d.ts

@@ -4,9 +4,9 @@ import type { Request } from '../types.js';
  * Extracts parameters from a Postman request and converts them to OpenAPI parameter objects.
  * Processes query, path, and header parameters from the request URL and headers.
  */
-export declare function extractParameters(request: Request): OpenAPIV3_1.ParameterObject[];
+export declare function extractParameters(request: Request, exampleName: string): OpenAPIV3_1.ParameterObject[];
 /**
  * Creates an OpenAPI parameter object from a Postman parameter.
  */
-export declare function createParameterObject(param: any, paramIn: 'query' | 'path' | 'header'): OpenAPIV3_1.ParameterObject;
+export declare function createParameterObject(param: any, paramIn: 'query' | 'path' | 'header', exampleName: string): OpenAPIV3_1.ParameterObject;
 //# sourceMappingURL=parameters.d.ts.map

package/dist/helpers/parameters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parameters.d.ts","sourceRoot":"","sources":["../../src/helpers/parameters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAExD,OAAO,KAAK,EAAU,OAAO,EAAE,MAAM,SAAS,CAAA;AAI9C;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,WAAW,CAAC,eAAe,EAAE,CA2DjF;AAoBD;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,GAAG,WAAW,CAAC,eAAe,CAmDnH"}
+{"version":3,"file":"parameters.d.ts","sourceRoot":"","sources":["../../src/helpers/parameters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAExD,OAAO,KAAK,EAAU,OAAO,EAAE,MAAM,SAAS,CAAA;AAI9C;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,GAAG,WAAW,CAAC,eAAe,EAAE,CA2DtG;AAoBD;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,GAAG,EACV,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,EACpC,WAAW,EAAE,MAAM,GAClB,WAAW,CAAC,eAAe,CAwD7B"}

package/dist/helpers/parameters.js

@@ -1,103 +1,131 @@
-import { inferSchemaType } from "./schemas.js";
-function extractParameters(request) {
-  const parameters = [];
-  const parameterMap = /* @__PURE__ */ new Map();
-  if (typeof request === "string" || !request.url) {
-    return parameters;
-  }
-  const url = typeof request.url === "string" ? { raw: request.url } : request.url;
-  if (url.query) {
-    url.query.forEach((param) => {
-      const paramObj = createParameterObject(param, "query");
-      if (paramObj.name) {
-        parameterMap.set(paramObj.name, paramObj);
-      }
-    });
-  }
-  if (url.variable) {
-    url.variable.forEach((param) => {
-      const paramObj = createParameterObject(param, "path");
-      if (paramObj.name) {
-        parameterMap.set(paramObj.name, paramObj);
-      }
-    });
-  }
-  if (url.path) {
-    const pathArray = Array.isArray(url.path) ? url.path : [url.path];
-    const extractedVariables = extractPathVariablesFromPathArray(pathArray);
-    extractedVariables.forEach((varName) => {
-      if (!parameterMap.has(varName)) {
-        parameterMap.set(varName, {
-          name: varName,
-          in: "path",
-          required: true,
-          schema: {
-            type: "string"
-          }
+import { inferSchemaType } from './schemas.js';
+/**
+ * Extracts parameters from a Postman request and converts them to OpenAPI parameter objects.
+ * Processes query, path, and header parameters from the request URL and headers.
+ */
+export function extractParameters(request, exampleName) {
+    const parameters = [];
+    const parameterMap = new Map();
+    if (typeof request === 'string' || !request.url) {
+        return parameters;
+    }
+    const url = typeof request.url === 'string' ? { raw: request.url } : request.url;
+    // Process query parameters
+    if (url.query) {
+        url.query.forEach((param) => {
+            const paramObj = createParameterObject(param, 'query', exampleName);
+            if (paramObj.name) {
+                parameterMap.set(paramObj.name, paramObj);
+            }
         });
-      }
-    });
-  }
-  if (request.header && Array.isArray(request.header)) {
-    request.header.forEach((header) => {
-      const paramObj = createParameterObject(header, "header");
-      if (paramObj.name) {
-        parameterMap.set(paramObj.name, paramObj);
-      }
-    });
-  }
-  return Array.from(parameterMap.values());
+    }
+    // Process path parameters
+    if (url.variable) {
+        url.variable.forEach((param) => {
+            const paramObj = createParameterObject(param, 'path', exampleName);
+            if (paramObj.name) {
+                parameterMap.set(paramObj.name, paramObj);
+            }
+        });
+    }
+    // Include variables extracted from url.path array
+    if (url.path) {
+        const pathArray = Array.isArray(url.path) ? url.path : [url.path];
+        const extractedVariables = extractPathVariablesFromPathArray(pathArray);
+        extractedVariables.forEach((varName) => {
+            if (!parameterMap.has(varName)) {
+                parameterMap.set(varName, {
+                    name: varName,
+                    in: 'path',
+                    required: true,
+                    schema: {
+                        type: 'string',
+                    },
+                });
+            }
+        });
+    }
+    // Process header parameters
+    if (request.header && Array.isArray(request.header)) {
+        request.header.forEach((header) => {
+            const paramObj = createParameterObject(header, 'header', exampleName);
+            if (paramObj.name) {
+                parameterMap.set(paramObj.name, paramObj);
+            }
+        });
+    }
+    return Array.from(parameterMap.values());
 }
+/**
+ * Helper function to extract variables from the url.path array.
+ */
 function extractPathVariablesFromPathArray(pathArray) {
-  const variables = [];
-  const variableRegex = /{{\s*([\w.-]+)\s*}}/;
-  pathArray.forEach((segment) => {
-    const segmentString = typeof segment === "string" ? segment : segment.value;
-    const match = segmentString.match(variableRegex);
-    if (match?.[1]) {
-      variables.push(match[1]);
-    }
-  });
-  return variables;
+    const variables = [];
+    const variableRegex = /{{\s*([\w.-]+)\s*}}/;
+    pathArray.forEach((segment) => {
+        const segmentString = typeof segment === 'string' ? segment : segment.value;
+        const match = segmentString.match(variableRegex);
+        if (match?.[1]) {
+            variables.push(match[1]);
+        }
+    });
+    return variables;
 }
-function createParameterObject(param, paramIn) {
-  const parameter = {
-    name: param.key || "",
-    in: paramIn,
-    description: param.description
-  };
-  if (paramIn === "path") {
-    parameter.required = true;
-  } else if (paramIn === "query") {
-    const isRequired = param.description?.toLowerCase().includes("[required]") || param.key && param.key.toLowerCase() === "required";
-    if (isRequired) {
-      parameter.required = true;
-      if (parameter.description) {
-        parameter.description = parameter.description.replace(/\[required\]/gi, "").trim();
-      }
+/**
+ * Creates an OpenAPI parameter object from a Postman parameter.
+ */
+export function createParameterObject(param, paramIn, exampleName) {
+    const parameter = {
+        name: param.key || '',
+        in: paramIn,
+        description: param.description,
+        examples: {
+            [exampleName]: {
+                value: param.value,
+                'x-disabled': !!param.disabled,
+            },
+        },
+    };
+    // Path parameters are always required in OpenAPI
+    if (paramIn === 'path') {
+        parameter.required = true;
+    }
+    else if (paramIn === 'query') {
+        // Check if the parameter is required based on description or name
+        const isRequired = param.description?.toLowerCase().includes('[required]') || (param.key && param.key.toLowerCase() === 'required');
+        if (isRequired) {
+            parameter.required = true;
+            // Remove '[required]' from the description
+            if (parameter.description) {
+                parameter.description = parameter.description.replace(/\[required\]/gi, '').trim();
+            }
+        }
+    }
+    if (param.value !== undefined) {
+        // For path parameters, prefer string type unless value is explicitly a number type
+        // This prevents converting string IDs like "testId" to integers
+        if (paramIn === 'path') {
+            // Path parameters are typically strings (IDs, slugs, etc.)
+            // Only use number/integer if the value is actually a number type, not a string
+            if (typeof param.value === 'number') {
+                parameter.schema = inferSchemaType(param.value);
+            }
+            else {
+                // For strings (including empty strings), default to string type
+                parameter.schema = { type: 'string' };
+            }
+        }
+        else {
+            parameter.schema = inferSchemaType(param.value);
+        }
+    }
+    else {
+        parameter.schema = { type: 'string' }; // Default to string if no value is provided
     }
-  }
-  if (param.value !== void 0) {
-    parameter.example = param.value;
-    if (paramIn === "path") {
-      if (typeof param.value === "number") {
-        parameter.schema = inferSchemaType(param.value);
-      } else {
-        parameter.schema = { type: "string" };
-      }
-    } else {
-      parameter.schema = inferSchemaType(param.value);
+    // Add x-scalar-disabled extension if parameter is disabled
+    if (param.disabled === true) {
+        // @ts-expect-error - x-scalar-disabled is not a valid parameter object property
+        parameter['x-scalar-disabled'] = true;
     }
-  } else {
-    parameter.schema = { type: "string" };
-  }
-  if (param.disabled === true) {
-    parameter["x-scalar-disabled"] = true;
-  }
-  return parameter;
+    return parameter;
 }
-export {
-  createParameterObject,
-  extractParameters
-};
-//# sourceMappingURL=parameters.js.map

package/dist/helpers/path-items.d.ts

@@ -15,7 +15,7 @@ export type ServerUsage = {
  * Handles nested item groups, extracts request details, and generates corresponding
  * OpenAPI path items and operations.
  */
-export declare function processItem(item: Item | ItemGroup, parentTags?: string[], parentPath?: string): {
+export declare function processItem(item: Item | ItemGroup, exampleName?: string, parentTags?: string[], parentPath?: string): {
     paths: OpenAPIV3_1.PathsObject;
     components: OpenAPIV3_1.ComponentsObject;
     serverUsage: ServerUsage[];

package/dist/helpers/path-items.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"path-items.d.ts","sourceRoot":"","sources":["../../src/helpers/path-items.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAExD,OAAO,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAW9C,KAAK,WAAW,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAA;AAE7F;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,WAAW,CAAA;CACpB,CAAA;AAoBD;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,IAAI,GAAG,SAAS,EACtB,UAAU,GAAE,MAAM,EAAO,EACzB,UAAU,GAAE,MAAW,GACtB;IACD,KAAK,EAAE,WAAW,CAAC,WAAW,CAAA;IAC9B,UAAU,EAAE,WAAW,CAAC,gBAAgB,CAAA;IACxC,WAAW,EAAE,WAAW,EAAE,CAAA;CAC3B,CA2KA"}
+{"version":3,"file":"path-items.d.ts","sourceRoot":"","sources":["../../src/helpers/path-items.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAExD,OAAO,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAW9C,KAAK,WAAW,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAA;AAE7F;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,WAAW,CAAA;CACpB,CAAA;AAoBD;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,IAAI,GAAG,SAAS,EACtB,WAAW,GAAE,MAAkB,EAC/B,UAAU,GAAE,MAAM,EAAO,EACzB,UAAU,GAAE,MAAW,GACtB;IACD,KAAK,EAAE,WAAW,CAAC,WAAW,CAAA;IAC9B,UAAU,EAAE,WAAW,CAAC,gBAAgB,CAAA;IACxC,WAAW,EAAE,WAAW,EAAE,CAAA;CAC3B,CA2KA"}