@scalar/postman-to-openapi 0.5.3 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @scalar/postman-to-openapi
 
+## 0.6.0
+
+### Minor Changes
+
+- [#8511](https://github.com/scalar/scalar/pull/8511): feat: support duplicate operations
+
 ## 0.5.3
 
 ### Patch Changes

package/dist/convert.d.ts

@@ -1,9 +1,37 @@
 import type { OpenAPIV3_1 } from '@scalar/openapi-types';
 import type { PostmanCollection } from './types.js';
+/**
+ * Indices from the collection root into nested `item` arrays.
+ * Example: `[0, 2, 1]` → `collection.item[0].item[2].item[1]`.
+ */
+export type PostmanRequestIndexPath = readonly number[];
+export type ConvertOptions = {
+    /**
+     * Whether to merge operations with the same path and method.
+     * If true, the operations will be merged into a single operation.
+     * If false, the operations will be kept as separate operations.
+     * Default is true.
+     */
+    mergeOperation?: boolean;
+    /**
+     * When set, only items at these paths are converted. Each path is a list of
+     * zero-based indices from `collection.item` through nested `item` arrays.
+     * The last index may point to a request or a folder; folders include every
+     * descendant request. Paths out of range or through non-folders are skipped.
+     * When omitted, the whole collection is converted (existing behavior).
+     */
+    requestIndexPaths?: readonly PostmanRequestIndexPath[];
+    /**
+     * Existing OpenAPI document to merge into. The input is is updated with Postman paths,
+     * tags (union by name), security schemes, and servers.
+     * Root `info` and existing paths are preserved unless Postman adds or merges operations.
+     */
+    document?: OpenAPIV3_1.Document;
+};
 /**
  * Converts a Postman Collection to an OpenAPI 3.1.0 document.
  * This function processes the collection's information, servers, authentication,
  * and items to create a corresponding OpenAPI structure.
  */
-export declare function convert(postmanCollection: PostmanCollection | string): OpenAPIV3_1.Document;
+export declare function convert(postmanCollection: PostmanCollection | string, options?: ConvertOptions): OpenAPIV3_1.Document;
 //# sourceMappingURL=convert.d.ts.map

package/dist/convert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["../src/convert.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAYxD,OAAO,KAAK,EAAgC,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAkL9E;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,iBAAiB,EAAE,iBAAiB,GAAG,MAAM,GAAG,WAAW,CAAC,QAAQ,CA6I3F"}
+{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["../src/convert.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAaxD,OAAO,KAAK,EAAgC,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAE9E;;;GAGG;AACH,MAAM,MAAM,uBAAuB,GAAG,SAAS,MAAM,EAAE,CAAA;AA4SvD,MAAM,MAAM,cAAc,GAAG;IAC3B;;;;;OAKG;IACH,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,SAAS,uBAAuB,EAAE,CAAA;IACtD;;;;OAIG;IACH,QAAQ,CAAC,EAAE,WAAW,CAAC,QAAQ,CAAA;CAChC,CAAA;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CACrB,iBAAiB,EAAE,iBAAiB,GAAG,MAAM,EAC7C,OAAO,GAAE,cAA0C,GAClD,WAAW,CAAC,QAAQ,CAwLtB"}

package/dist/convert.js

@@ -3,20 +3,11 @@ import { processContact } from './helpers/contact.js';
 import { processExternalDocs } from './helpers/external-docs.js';
 import { processLicense } from './helpers/license.js';
 import { processLogo } from './helpers/logo.js';
+import { DEFAULT_EXAMPLE_NAME, OPERATION_KEYS, mergePathItem } from './helpers/merge-path-item.js';
 import { processItem } from './helpers/path-items.js';
 import { pruneDocument } from './helpers/prune-document.js';
 import { analyzeServerDistribution } from './helpers/servers.js';
 import { normalizePath } from './helpers/urls.js';
-const OPERATION_KEYS = [
-    'get',
-    'put',
-    'post',
-    'delete',
-    'options',
-    'head',
-    'patch',
-    'trace',
-];
 const normalizeDescription = (description) => {
     if (typeof description === 'string') {
         return description;
@@ -87,6 +78,95 @@ const extractTags = (items) => {
     };
     return items.flatMap((item) => collectTags(item));
 };
+/**
+ * Folder tags for ancestors of each selected path only (same shape as {@link extractTags}).
+ */
+const extractTagsForSelectedPaths = (items, paths) => {
+    const seen = new Set();
+    const result = [];
+    for (const path of paths) {
+        if (path.length === 0) {
+            continue;
+        }
+        let list = items;
+        let parentPath = '';
+        for (let i = 0; i < path.length - 1; i++) {
+            const idx = path[i];
+            if (idx === undefined || idx < 0 || idx >= list.length) {
+                break;
+            }
+            const node = list[idx];
+            if (node === undefined || !isItemGroup(node)) {
+                break;
+            }
+            const nextPath = node.name ? (parentPath ? `${parentPath} > ${node.name}` : node.name) : parentPath;
+            const description = normalizeDescription(node.description);
+            if (node.name?.length && !seen.has(nextPath)) {
+                seen.add(nextPath);
+                result.push({
+                    name: nextPath,
+                    ...(description && { description }),
+                });
+            }
+            parentPath = nextPath;
+            list = node.item;
+        }
+    }
+    return result;
+};
+const getNodeAtPath = (items, path) => {
+    if (path.length === 0) {
+        return undefined;
+    }
+    let list = items;
+    let node;
+    for (let i = 0; i < path.length; i++) {
+        const idx = path[i];
+        if (idx === undefined || idx < 0 || idx >= list.length) {
+            return undefined;
+        }
+        node = list[idx];
+        if (node === undefined) {
+            return undefined;
+        }
+        if (i < path.length - 1) {
+            if (!isItemGroup(node)) {
+                return undefined;
+            }
+            list = node.item;
+        }
+    }
+    return node;
+};
+const collectParentTagSegments = (items, path) => {
+    const segments = [];
+    if (path.length <= 1) {
+        return segments;
+    }
+    let list = items;
+    for (let i = 0; i < path.length - 1; i++) {
+        const idx = path[i];
+        if (idx === undefined || idx < 0 || idx >= list.length) {
+            return [];
+        }
+        const node = list[idx];
+        if (node === undefined || !isItemGroup(node)) {
+            return [];
+        }
+        if (node.name) {
+            segments.push(node.name);
+        }
+        list = node.item;
+    }
+    return segments;
+};
+const dedupeIndexPaths = (paths) => {
+    const map = new Map();
+    for (const path of paths) {
+        map.set(JSON.stringify([...path]), path);
+    }
+    return [...map.values()];
+};
 const mergeSecuritySchemes = (openapi, securitySchemes) => {
     if (!securitySchemes || Object.keys(securitySchemes).length === 0) {
         return;
@@ -97,20 +177,40 @@ const mergeSecuritySchemes = (openapi, securitySchemes) => {
         ...securitySchemes,
     };
 };
-const mergePathItem = (paths, normalizedPathKey, pathItem) => {
-    const targetPath = (paths[normalizedPathKey] ?? {});
-    for (const [key, value] of Object.entries(pathItem)) {
-        if (value === undefined) {
-            continue;
+const mergeServerLists = (existing, incoming) => {
+    const seen = new Set((existing ?? []).map((s) => s.url));
+    const out = [...(existing ?? [])];
+    for (const server of incoming) {
+        if (!seen.has(server.url)) {
+            seen.add(server.url);
+            out.push(server);
         }
-        const isOperationKey = OPERATION_KEYS.includes(key);
-        if (isOperationKey && targetPath[key]) {
-            const operationName = typeof key === 'string' ? key.toUpperCase() : String(key);
-            console.warn(`Duplicate operation detected for ${operationName} ${normalizedPathKey}. Last operation will overwrite previous.`);
-        }
-        targetPath[key] = value;
     }
-    paths[normalizedPathKey] = targetPath;
+    return out;
+};
+const mergeTagsIntoDocument = (openapi, incoming) => {
+    if (incoming.length === 0) {
+        return;
+    }
+    const existing = openapi.tags ?? [];
+    if (existing.length === 0) {
+        openapi.tags = incoming;
+        return;
+    }
+    const names = new Set(existing.map((t) => t.name));
+    const additions = incoming.filter((t) => t.name && !names.has(t.name));
+    openapi.tags = additions.length > 0 ? [...existing, ...additions] : existing;
+};
+const assignTagsFromPostman = (openapi, tags, isMergingIntoBase) => {
+    if (tags.length === 0) {
+        return;
+    }
+    if (isMergingIntoBase) {
+        mergeTagsIntoDocument(openapi, tags);
+    }
+    else {
+        openapi.tags = tags;
+    }
 };
 const cleanupOperations = (paths) => {
     Object.values(paths).forEach((pathItem) => {
@@ -145,7 +245,9 @@ const cleanupOperations = (paths) => {
  * This function processes the collection's information, servers, authentication,
  * and items to create a corresponding OpenAPI structure.
  */
-export function convert(postmanCollection) {
+export function convert(postmanCollection, options = { mergeOperation: false }) {
+    const { requestIndexPaths, mergeOperation = false, document: baseDocument } = options;
+    const isMergingIntoBase = baseDocument !== undefined;
     const collection = validateCollectionShape(parseCollectionInput(postmanCollection));
     // Extract title from collection info, fallback to 'API' if not provided
     const title = collection.info.name || 'API';
@@ -158,8 +260,8 @@ export function convert(postmanCollection) {
     const contact = processContact(collection);
     // Process logo information
     const logo = processLogo(collection);
-    // Initialize the OpenAPI document with required fields
-    const openapi = {
+    // Initialize the OpenAPI document with required fields (or clone a base document to merge into)
+    const openapi = baseDocument ?? {
         openapi: '3.1.0',
         info: {
             title,
@@ -171,44 +273,72 @@ export function convert(postmanCollection) {
         },
         paths: {},
     };
+    openapi.paths = openapi.paths ?? {};
     // Process external docs
     const externalDocs = processExternalDocs(collection);
-    if (externalDocs) {
+    if (externalDocs && (!isMergingIntoBase || !openapi.externalDocs)) {
         openapi.externalDocs = externalDocs;
     }
     // Process authentication if present in the collection
     if (collection.auth) {
         const { securitySchemes, security } = processAuth(collection.auth);
         mergeSecuritySchemes(openapi, securitySchemes);
-        openapi.security = security;
+        if (security?.length) {
+            if (isMergingIntoBase && openapi.security?.length) {
+                openapi.security = [...openapi.security, ...security];
+            }
+            else {
+                openapi.security = security;
+            }
+        }
     }
     // Process each item in the collection and merge into OpenAPI spec
     const allServerUsage = [];
     if (collection.item) {
-        // Extract tags from folders
-        const tags = extractTags(collection.item);
-        if (tags.length > 0) {
-            openapi.tags = tags;
-        }
-        collection.item.forEach((item) => {
-            const { paths: itemPaths, components: itemComponents, serverUsage } = processItem(item);
-            // Collect server usage information
-            allServerUsage.push(...serverUsage);
-            // Merge paths from the current item
-            openapi.paths = openapi.paths || {};
-            for (const [pathKey, pathItem] of Object.entries(itemPaths)) {
-                // Convert colon-style params to curly brace style
-                const normalizedPathKey = normalizePath(pathKey);
-                if (!pathItem) {
+        const usePathFilter = requestIndexPaths !== undefined;
+        if (usePathFilter) {
+            const uniquePaths = dedupeIndexPaths(requestIndexPaths);
+            const tags = extractTagsForSelectedPaths(collection.item, uniquePaths);
+            assignTagsFromPostman(openapi, tags, isMergingIntoBase);
+            for (const path of uniquePaths) {
+                const node = getNodeAtPath(collection.item, path);
+                if (!node) {
                     continue;
                 }
-                mergePathItem(openapi.paths, normalizedPathKey, pathItem);
-            }
-            // Merge security schemes from the current item
-            if (itemComponents?.securitySchemes) {
-                mergeSecuritySchemes(openapi, itemComponents.securitySchemes);
+                const parentTags = collectParentTagSegments(collection.item, path);
+                const { paths: itemPaths, components: itemComponents, serverUsage, } = processItem(node, DEFAULT_EXAMPLE_NAME, parentTags, '');
+                allServerUsage.push(...serverUsage);
+                for (const [pathKey, pathItem] of Object.entries(itemPaths)) {
+                    const normalizedPathKey = normalizePath(pathKey);
+                    if (!pathItem) {
+                        continue;
+                    }
+                    mergePathItem(openapi.paths, normalizedPathKey, pathItem, mergeOperation);
+                }
+                if (itemComponents?.securitySchemes) {
+                    mergeSecuritySchemes(openapi, itemComponents.securitySchemes);
+                }
             }
-        });
+        }
+        else {
+            const tags = extractTags(collection.item);
+            assignTagsFromPostman(openapi, tags, isMergingIntoBase);
+            collection.item.forEach((item) => {
+                const { paths: itemPaths, components: itemComponents, serverUsage } = processItem(item, DEFAULT_EXAMPLE_NAME);
+                allServerUsage.push(...serverUsage);
+                openapi.paths = openapi.paths || {};
+                for (const [pathKey, pathItem] of Object.entries(itemPaths)) {
+                    const normalizedPathKey = normalizePath(pathKey);
+                    if (!pathItem) {
+                        continue;
+                    }
+                    mergePathItem(openapi.paths, normalizedPathKey, pathItem, mergeOperation);
+                }
+                if (itemComponents?.securitySchemes) {
+                    mergeSecuritySchemes(openapi, itemComponents.securitySchemes);
+                }
+            });
+        }
     }
     // Extract all unique paths from the document
     const allUniquePaths = new Set();
@@ -221,7 +351,9 @@ export function convert(postmanCollection) {
     const serverPlacement = analyzeServerDistribution(allServerUsage, allUniquePaths);
     // Add servers to document level
     if (serverPlacement.document.length > 0) {
-        openapi.servers = serverPlacement.document;
+        openapi.servers = isMergingIntoBase
+            ? mergeServerLists(openapi.servers, serverPlacement.document)
+            : serverPlacement.document;
     }
     // Add servers to path items
     if (openapi.paths) {
@@ -229,7 +361,7 @@ export function convert(postmanCollection) {
             const normalizedPathKey = normalizePath(path);
             const pathItem = openapi.paths[normalizedPathKey];
             if (pathItem) {
-                pathItem.servers = servers;
+                pathItem.servers = isMergingIntoBase ? mergeServerLists(pathItem.servers, servers) : servers;
             }
         }
         // Add servers to operations
@@ -243,7 +375,7 @@ export function convert(postmanCollection) {
                 if (method in pathItem) {
                     const operation = pathItem[method];
                     if (operation && typeof operation === 'object' && 'responses' in operation) {
-                        operation.servers = servers;
+                        operation.servers = isMergingIntoBase ? mergeServerLists(operation.servers, servers) : servers;
                     }
                 }
             }

package/dist/helpers/generate-unique-value.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Generates a unique string value based on a default value and a validation function.
+ * The function tries the default value first. If validation fails, it appends
+ * an incrementing suffix (optionally with a prefix) until the validation passes.
+ *
+ * @param defaultValue - The initial base string value to try.
+ * @param validation - A function that receives a candidate value and returns true if it is valid.
+ * @param prefix - Optional prefix to add before the incrementing number (default is '').
+ * @returns The first value that passes the validation.
+ *
+ * @example
+ * // Case 1: Simple unused value
+ * generateUniqueValue('example', v => v !== 'example') // → "example 2"
+ *
+ * // Case 2: Avoids taken values in a set
+ * const taken = new Set(['foo', 'foo 1', 'foo 2']);
+ * generateUniqueValue('foo', v => !taken.has(v)) // → "foo 3"
+ *
+ * // Case 3: Using a prefix
+ * generateUniqueValue('base', v => v === 'base__3', '__') // → "base__3"
+ */
+export declare const generateUniqueValue: (defaultValue: string, validation: (value: string) => boolean, prefix?: string) => string;
+//# sourceMappingURL=generate-unique-value.d.ts.map

package/dist/helpers/generate-unique-value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-unique-value.d.ts","sourceRoot":"","sources":["../../src/helpers/generate-unique-value.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,mBAAmB,GAC9B,cAAc,MAAM,EACpB,YAAY,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,EACtC,eAAW,KACV,MAOF,CAAA"}

package/dist/helpers/generate-unique-value.js

@@ -0,0 +1,29 @@
+/**
+ * Generates a unique string value based on a default value and a validation function.
+ * The function tries the default value first. If validation fails, it appends
+ * an incrementing suffix (optionally with a prefix) until the validation passes.
+ *
+ * @param defaultValue - The initial base string value to try.
+ * @param validation - A function that receives a candidate value and returns true if it is valid.
+ * @param prefix - Optional prefix to add before the incrementing number (default is '').
+ * @returns The first value that passes the validation.
+ *
+ * @example
+ * // Case 1: Simple unused value
+ * generateUniqueValue('example', v => v !== 'example') // → "example 2"
+ *
+ * // Case 2: Avoids taken values in a set
+ * const taken = new Set(['foo', 'foo 1', 'foo 2']);
+ * generateUniqueValue('foo', v => !taken.has(v)) // → "foo 3"
+ *
+ * // Case 3: Using a prefix
+ * generateUniqueValue('base', v => v === 'base__3', '__') // → "base__3"
+ */
+export const generateUniqueValue = (defaultValue, validation, prefix = '') => {
+    let i = 1;
+    let value = defaultValue;
+    while (!validation(value)) {
+        value = `${defaultValue} ${prefix}${i++}`;
+    }
+    return value;
+};

package/dist/helpers/get-operation-examples.d.ts

@@ -0,0 +1,40 @@
+import type { OpenAPIV3_1 } from '@scalar/openapi-types';
+/**
+ * Collects all example names used on parameters and requestBodies
+ * within all operations of a PathItemObject.
+ *
+ * This is useful for checking which example names are already present
+ * so you can avoid clashes (e.g., generating unique example names
+ * when merging path items).
+ *
+ * @param path - The OpenAPI PathItemObject to scan
+ * @returns Set of all unique example names found across parameters and requestBodies
+ *
+ * @example
+ * const operation: OpenAPIV3_1.OperationObject = {
+ *   parameters: [
+ *     {
+ *       name: 'id',
+ *       in: 'query',
+ *       examples: {
+ *         foo: { value: 'bar' },
+ *         bar: { value: 'baz' }
+ *       }
+ *     }
+ *   ],
+ *   requestBody: {
+ *     content: {
+ *       'application/json': {
+ *         examples: {
+ *           default: { value: 1 },
+ *           extra: { value: 2 }
+ *         }
+ *       }
+ *     }
+ *   }
+ * }
+ * const path = { get: operation }
+ * // getOperationExamples(path) => Set { 'foo', 'bar', 'default', 'extra' }
+ */
+export declare const getOperationExamples: (path: OpenAPIV3_1.PathItemObject) => Set<string>;
+//# sourceMappingURL=get-operation-examples.d.ts.map

package/dist/helpers/get-operation-examples.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-operation-examples.d.ts","sourceRoot":"","sources":["../../src/helpers/get-operation-examples.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,oBAAoB,GAAI,MAAM,WAAW,CAAC,cAAc,gBA2CpE,CAAA"}

package/dist/helpers/get-operation-examples.js

@@ -0,0 +1,76 @@
+import { HTTP_METHODS } from '@scalar/helpers/http/http-methods';
+/**
+ * Collects all example names used on parameters and requestBodies
+ * within all operations of a PathItemObject.
+ *
+ * This is useful for checking which example names are already present
+ * so you can avoid clashes (e.g., generating unique example names
+ * when merging path items).
+ *
+ * @param path - The OpenAPI PathItemObject to scan
+ * @returns Set of all unique example names found across parameters and requestBodies
+ *
+ * @example
+ * const operation: OpenAPIV3_1.OperationObject = {
+ *   parameters: [
+ *     {
+ *       name: 'id',
+ *       in: 'query',
+ *       examples: {
+ *         foo: { value: 'bar' },
+ *         bar: { value: 'baz' }
+ *       }
+ *     }
+ *   ],
+ *   requestBody: {
+ *     content: {
+ *       'application/json': {
+ *         examples: {
+ *           default: { value: 1 },
+ *           extra: { value: 2 }
+ *         }
+ *       }
+ *     }
+ *   }
+ * }
+ * const path = { get: operation }
+ * // getOperationExamples(path) => Set { 'foo', 'bar', 'default', 'extra' }
+ */
+export const getOperationExamples = (path) => {
+    const exampleNames = new Set();
+    for (const key of HTTP_METHODS) {
+        const operation = path[key];
+        if (operation === undefined || typeof operation !== 'object') {
+            continue;
+        }
+        const op = operation;
+        if ('parameters' in op) {
+            op.parameters?.forEach((parameter) => {
+                if (parameter.examples) {
+                    for (const exampleName of Object.keys(parameter.examples)) {
+                        exampleNames.add(exampleName);
+                    }
+                }
+            });
+        }
+        if ('requestBody' in op) {
+            const requestBody = op.requestBody;
+            if (requestBody?.content) {
+                for (const mediaTypeObject of Object.values(requestBody.content)) {
+                    const examples = mediaTypeObject &&
+                        typeof mediaTypeObject === 'object' &&
+                        'examples' in mediaTypeObject &&
+                        typeof mediaTypeObject.examples === 'object'
+                        ? mediaTypeObject.examples
+                        : undefined;
+                    if (examples) {
+                        for (const exampleName of Object.keys(examples)) {
+                            exampleNames.add(exampleName);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return exampleNames;
+};

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

@@ -3,7 +3,7 @@ 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) {
+export function extractParameters(request, exampleName) {
     const parameters = [];
     const parameterMap = new Map();
     if (typeof request === 'string' || !request.url) {
@@ -13,7 +13,7 @@ export function extractParameters(request) {
     // Process query parameters
     if (url.query) {
         url.query.forEach((param) => {
-            const paramObj = createParameterObject(param, 'query');
+            const paramObj = createParameterObject(param, 'query', exampleName);
             if (paramObj.name) {
                 parameterMap.set(paramObj.name, paramObj);
             }
@@ -22,7 +22,7 @@ export function extractParameters(request) {
     // Process path parameters
     if (url.variable) {
         url.variable.forEach((param) => {
-            const paramObj = createParameterObject(param, 'path');
+            const paramObj = createParameterObject(param, 'path', exampleName);
             if (paramObj.name) {
                 parameterMap.set(paramObj.name, paramObj);
             }
@@ -48,7 +48,7 @@ export function extractParameters(request) {
     // Process header parameters
     if (request.header && Array.isArray(request.header)) {
         request.header.forEach((header) => {
-            const paramObj = createParameterObject(header, 'header');
+            const paramObj = createParameterObject(header, 'header', exampleName);
             if (paramObj.name) {
                 parameterMap.set(paramObj.name, paramObj);
             }
@@ -74,11 +74,17 @@ function extractPathVariablesFromPathArray(pathArray) {
 /**
  * Creates an OpenAPI parameter object from a Postman parameter.
  */
-export function createParameterObject(param, paramIn) {
+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') {
@@ -96,7 +102,6 @@ export function createParameterObject(param, paramIn) {
         }
     }
     if (param.value !== undefined) {
-        parameter.example = param.value;
         // 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') {

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"}

package/dist/helpers/path-items.js

@@ -27,14 +27,14 @@ function ensureRequestBodyContent(requestBody) {
  * Handles nested item groups, extracts request details, and generates corresponding
  * OpenAPI path items and operations.
  */
-export function processItem(item, parentTags = [], parentPath = '') {
+export function processItem(item, exampleName = 'default', parentTags = [], parentPath = '') {
     const paths = {};
     const components = {};
     const serverUsage = [];
     if ('item' in item && Array.isArray(item.item)) {
         const newParentTags = item.name ? [...parentTags, item.name] : parentTags;
         item.item.forEach((childItem) => {
-            const childResult = processItem(childItem, newParentTags, `${parentPath}/${item.name || ''}`);
+            const childResult = processItem(childItem, exampleName, newParentTags, `${parentPath}/${item.name || ''}`);
             // Merge child paths and components
             for (const [pathKey, pathItem] of Object.entries(childResult.paths)) {
                 if (!paths[pathKey]) {
@@ -109,7 +109,7 @@ export function processItem(item, parentTags = [], parentPath = '') {
     }
     // Extract parameters from the request (query, path, header)
     // This should always happen, regardless of whether a description exists
-    const extractedParameters = extractParameters(request);
+    const extractedParameters = extractParameters(request, exampleName);
     // Merge parameters, giving priority to those from the Markdown table if description exists
     const mergedParameters = new Map();
     // Add extracted parameters, filtering out path parameters not in the path
@@ -156,7 +156,7 @@ export function processItem(item, parentTags = [], parentPath = '') {
     }
     // Allow request bodies for all methods (including GET) if body is present
     if (typeof request !== 'string' && request.body) {
-        const requestBody = extractRequestBody(request.body);
+        const requestBody = extractRequestBody(request.body, exampleName);
         ensureRequestBodyContent(requestBody);
         // Only add requestBody if it has content
         if (requestBody.content && Object.keys(requestBody.content).length > 0) {
@@ -175,8 +175,9 @@ const OPENAPI_PARAM_SCHEMA_TYPES = ['string', 'number', 'integer', 'boolean', 'o
 function toOpenApiParamSchemaType(s) {
     const value = s ?? 'string';
     for (const t of OPENAPI_PARAM_SCHEMA_TYPES) {
-        if (t === value)
+        if (t === value) {
             return t;
+        }
     }
     return 'string';
 }

package/dist/helpers/rename-operation-example.d.ts

@@ -0,0 +1,40 @@
+import type { OpenAPIV3_1 } from '@scalar/openapi-types';
+/**
+ * Renames an example in all parameters and requestBody content of an operation object.
+ *
+ * This will copy the example (by name) and remove the old entry both for parameter examples
+ * and within every media type of the requestBody, if such examples exist.
+ *
+ * @param operation - The OpenAPI operation object to mutate
+ * @param exampleName - The existing example name to rename
+ * @param newExampleName - The new name to give that example
+ *
+ * @example
+ * // Given:
+ * const operation = {
+ *   parameters: [
+ *     {
+ *       name: 'foo',
+ *       in: 'query',
+ *       examples: {
+ *         oldName: { value: 'fooValue' }
+ *       }
+ *     }
+ *   ],
+ *   requestBody: {
+ *     content: {
+ *       'application/json': {
+ *         examples: {
+ *           oldName: { value: 123 }
+ *         }
+ *       }
+ *     }
+ *   }
+ * }
+ * renameOperationExamples(operation, 'oldName', 'newName')
+ * // After:
+ * // operation.parameters[0].examples: { newName: { value: 'fooValue' } }
+ * // operation.requestBody.content['application/json'].examples: { newName: { value: 123 } }
+ */
+export declare const renameOperationExamples: (operation: OpenAPIV3_1.OperationObject, exampleName: string, newExampleName: string) => void;
+//# sourceMappingURL=rename-operation-example.d.ts.map

package/dist/helpers/rename-operation-example.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rename-operation-example.d.ts","sourceRoot":"","sources":["../../src/helpers/rename-operation-example.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,uBAAuB,GAClC,WAAW,WAAW,CAAC,eAAe,EACtC,aAAa,MAAM,EACnB,gBAAgB,MAAM,KACrB,IA0BF,CAAA"}

package/dist/helpers/rename-operation-example.js

@@ -0,0 +1,61 @@
+/**
+ * Renames an example in all parameters and requestBody content of an operation object.
+ *
+ * This will copy the example (by name) and remove the old entry both for parameter examples
+ * and within every media type of the requestBody, if such examples exist.
+ *
+ * @param operation - The OpenAPI operation object to mutate
+ * @param exampleName - The existing example name to rename
+ * @param newExampleName - The new name to give that example
+ *
+ * @example
+ * // Given:
+ * const operation = {
+ *   parameters: [
+ *     {
+ *       name: 'foo',
+ *       in: 'query',
+ *       examples: {
+ *         oldName: { value: 'fooValue' }
+ *       }
+ *     }
+ *   ],
+ *   requestBody: {
+ *     content: {
+ *       'application/json': {
+ *         examples: {
+ *           oldName: { value: 123 }
+ *         }
+ *       }
+ *     }
+ *   }
+ * }
+ * renameOperationExamples(operation, 'oldName', 'newName')
+ * // After:
+ * // operation.parameters[0].examples: { newName: { value: 'fooValue' } }
+ * // operation.requestBody.content['application/json'].examples: { newName: { value: 123 } }
+ */
+export const renameOperationExamples = (operation, exampleName, newExampleName) => {
+    // Rename in parameter examples (if present)
+    if ('parameters' in operation) {
+        operation.parameters?.forEach((parameter) => {
+            if (parameter.examples?.[exampleName] && exampleName !== newExampleName) {
+                parameter.examples[newExampleName] = parameter.examples[exampleName];
+                delete parameter.examples[exampleName];
+            }
+        });
+    }
+    // Rename in requestBody content examples (if present)
+    if ('requestBody' in operation) {
+        Object.values(operation.requestBody?.content ?? {}).forEach((mediaTypeObject) => {
+            if (mediaTypeObject.examples &&
+                typeof mediaTypeObject.examples === 'object') {
+                const mediaCasted = mediaTypeObject;
+                if (mediaCasted.examples?.[exampleName] && exampleName !== newExampleName) {
+                    mediaCasted.examples[newExampleName] = mediaCasted.examples[exampleName];
+                    delete mediaCasted.examples[exampleName];
+                }
+            }
+        });
+    }
+};

package/dist/helpers/request-body.d.ts

@@ -4,5 +4,5 @@ import type { RequestBody } from '../types.js';
  * Extracts and converts the request body from a Postman request to an OpenAPI RequestBodyObject.
  * Handles raw JSON, form-data, and URL-encoded body types, creating appropriate schemas and content types.
  */
-export declare function extractRequestBody(body: RequestBody): OpenAPIV3_1.RequestBodyObject;
+export declare function extractRequestBody(body: RequestBody, exampleName: string): OpenAPIV3_1.RequestBodyObject;
 //# sourceMappingURL=request-body.d.ts.map

package/dist/helpers/request-body.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"request-body.d.ts","sourceRoot":"","sources":["../../src/helpers/request-body.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAExD,OAAO,KAAK,EAAiB,WAAW,EAAuB,MAAM,SAAS,CAAA;AAK9E;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,WAAW,GAAG,WAAW,CAAC,iBAAiB,CAqBnF"}
+{"version":3,"file":"request-body.d.ts","sourceRoot":"","sources":["../../src/helpers/request-body.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAExD,OAAO,KAAK,EAAiB,WAAW,EAAuB,MAAM,SAAS,CAAA;AAK9E;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,GAAG,WAAW,CAAC,iBAAiB,CAqBxG"}

package/dist/helpers/request-body.js

@@ -4,25 +4,25 @@ import { createParameterObject } from './parameters.js';
  * Extracts and converts the request body from a Postman request to an OpenAPI RequestBodyObject.
  * Handles raw JSON, form-data, and URL-encoded body types, creating appropriate schemas and content types.
  */
-export function extractRequestBody(body) {
+export function extractRequestBody(body, exampleName) {
     const requestBody = {
         content: {},
     };
     if (body.mode === 'raw') {
-        handleRawBody(body, requestBody);
+        handleRawBody(body, requestBody, exampleName);
         return requestBody;
     }
     if (body.mode === 'formdata' && body.formdata) {
-        handleFormDataBody(body.formdata, requestBody);
+        handleFormDataBody(body.formdata, requestBody, exampleName);
         return requestBody;
     }
     if (body.mode === 'urlencoded' && body.urlencoded) {
-        handleUrlEncodedBody(body.urlencoded, requestBody);
+        handleUrlEncodedBody(body.urlencoded, requestBody, exampleName);
         return requestBody;
     }
     return requestBody;
 }
-function handleRawBody(body, requestBody) {
+function handleRawBody(body, requestBody, exampleName) {
     const rawBody = body.raw || '';
     const isJsonLanguage = body.options?.raw?.language === 'json';
     // Check if body contains Postman variables (like {{bodyData}})
@@ -44,7 +44,11 @@ function handleRawBody(body, requestBody) {
             'application/json': {
                 schema: {
                     type: 'object',
-                    example: jsonBody,
+                },
+                examples: {
+                    [exampleName]: {
+                        value: jsonBody,
+                    },
                 },
             },
         };
@@ -73,14 +77,19 @@ function handleRawBody(body, requestBody) {
         },
     };
 }
-function handleFormDataBody(formdata, requestBody) {
+function handleFormDataBody(formdata, requestBody, exampleName) {
     requestBody.content = {
         'multipart/form-data': {
             schema: processFormDataSchema(formdata),
+            examples: {
+                [exampleName]: {
+                    value: formdata,
+                },
+            },
         },
     };
 }
-function handleUrlEncodedBody(urlencoded, requestBody) {
+function handleUrlEncodedBody(urlencoded, requestBody, exampleName) {
     const schema = {
         type: 'object',
         properties: {},
@@ -88,7 +97,7 @@ function handleUrlEncodedBody(urlencoded, requestBody) {
     };
     urlencoded.forEach((item) => {
         if (schema.properties) {
-            const paramObject = createParameterObject(item, 'query');
+            const paramObject = createParameterObject(item, 'query', exampleName);
             const property = {
                 type: 'string',
                 examples: [item.value],
@@ -107,6 +116,11 @@ function handleUrlEncodedBody(urlencoded, requestBody) {
     requestBody.content = {
         'application/x-www-form-urlencoded': {
             schema,
+            examples: {
+                [exampleName]: {
+                    value: urlencoded,
+                },
+            },
         },
     };
 }

package/dist/index.d.ts

@@ -1,2 +1,3 @@
-export { convert } from './convert.js';
+export { type ConvertOptions, type PostmanRequestIndexPath, convert } from './convert.js';
+export { extractPathFromUrl, normalizePath } from './helpers/urls.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,uBAAuB,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACtF,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA"}

package/dist/index.js

@@ -1 +1,2 @@
 export { convert } from './convert.js';
+export { extractPathFromUrl, normalizePath } from './helpers/urls.js';

package/package.json

@@ -19,7 +19,7 @@
     "export",
     "scalar"
   ],
-  "version": "0.5.3",
+  "version": "0.6.0",
   "engines": {
     "node": ">=22"
   },
@@ -38,8 +38,8 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "@scalar/openapi-types": "0.6.1",
-    "@scalar/helpers": "0.4.2"
+    "@scalar/helpers": "0.4.2",
+    "@scalar/openapi-types": "0.6.1"
   },
   "devDependencies": {
     "@types/node": "^24.1.0",
@@ -47,6 +47,7 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
+    "generate:textures": "tsx ./scripts/generate-textures.ts",
     "test": "vitest",
     "types:check": "tsc --noEmit"
   }