@scalar/postman-to-openapi 0.1.0

package/dist/helpers/itemHelpers.js

@@ -0,0 +1,236 @@
+import { processAuth } from './authHelpers.js';
+import { parseMdTable } from './md-utils.js';
+import { extractParameters } from './parameterHelpers.js';
+import { extractRequestBody } from './requestBodyHelpers.js';
+import { extractResponses } from './responseHelpers.js';
+import { extractStatusCodesFromTests } from './statusCodeHelpers.js';
+import { extractPathFromUrl, extractPathParameterNames, normalizePath, } from './urlHelpers.js';
+/**
+ * Processes a Postman collection item or item group and returns
+ * the corresponding OpenAPI paths and components.
+ * Handles nested item groups, extracts request details, and generates corresponding
+ * OpenAPI path items and operations.
+ */
+export function processItem(item, parentTags = [], parentPath = '') {
+    const paths = {};
+    const components = {};
+    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 || ''}`);
+            // Merge child paths and components
+            for (const [pathKey, pathItem] of Object.entries(childResult.paths)) {
+                if (!paths[pathKey]) {
+                    paths[pathKey] = pathItem;
+                }
+                else {
+                    paths[pathKey] = {
+                        ...paths[pathKey],
+                        ...pathItem,
+                    };
+                }
+            }
+            // Merge components.securitySchemes
+            if (childResult.components.securitySchemes) {
+                components.securitySchemes = {
+                    ...components.securitySchemes,
+                    ...childResult.components.securitySchemes,
+                };
+            }
+        });
+        return { paths, components };
+    }
+    if (!('request' in item)) {
+        return { paths, components };
+    }
+    const { request, name, response } = item;
+    const method = (typeof request === 'string' ? 'get' : request.method || 'get').toLowerCase();
+    const path = extractPathFromUrl(typeof request === 'string'
+        ? request
+        : typeof request.url === 'string'
+            ? request.url
+            : (request.url?.raw ?? ''));
+    // Normalize path parameters from ':param' to '{param}'
+    const normalizedPath = normalizePath(path);
+    // Extract path parameter names
+    const pathParameterNames = extractPathParameterNames(normalizedPath);
+    // Extract operation ID if present
+    const { operationId, summary } = extractOperationInfo(name);
+    const description = typeof request === 'string'
+        ? ''
+        : typeof request.description === 'string'
+            ? request.description
+            : (request.description?.content ?? '');
+    const operationObject = {
+        tags: parentTags.length > 0 ? [parentTags.join(' > ')] : ['default'],
+        summary,
+        description,
+        responses: extractResponses(response || []),
+        parameters: [],
+    };
+    // Only add operationId if it was explicitly provided
+    if (operationId) {
+        operationObject.operationId = operationId;
+    }
+    // Parse parameters from the description's Markdown table
+    if (operationObject.description) {
+        const { descriptionWithoutTable, parametersFromTable } = parseParametersFromDescription(operationObject.description);
+        operationObject.description = descriptionWithoutTable.trim();
+        // Extract parameters from the request (query, path, header)
+        const extractedParameters = extractParameters(request);
+        // Merge parameters, giving priority to those from the Markdown table
+        const mergedParameters = new Map();
+        // Add extracted parameters, filtering out path parameters not in the path
+        extractedParameters.forEach((param) => {
+            if (param.name) {
+                if (param.in === 'path' && !pathParameterNames.includes(param.name)) {
+                    return;
+                }
+                mergedParameters.set(param.name, param);
+            }
+        });
+        // Add parameters from table, filtering out path parameters not in the path
+        parametersFromTable.forEach((param) => {
+            if (param.name) {
+                if (param.in === 'path' && !pathParameterNames.includes(param.name)) {
+                    return;
+                }
+                mergedParameters.set(param.name, param);
+            }
+        });
+        operationObject.parameters = Array.from(mergedParameters.values());
+    }
+    if (typeof request !== 'string' && request.auth) {
+        if (!operationObject.security) {
+            operationObject.security = [];
+        }
+        const { securitySchemes, security } = processAuth(request.auth);
+        if (!components.securitySchemes) {
+            components.securitySchemes = {};
+        }
+        components.securitySchemes = {
+            ...components.securitySchemes,
+            ...securitySchemes,
+        };
+        operationObject.security.push(...security);
+    }
+    if (['post', 'put', 'patch'].includes(method) &&
+        typeof request !== 'string' &&
+        request.body) {
+        operationObject.requestBody = extractRequestBody(request.body);
+    }
+    if (!paths[path])
+        paths[path] = {};
+    const pathItem = paths[path];
+    pathItem[method] = operationObject;
+    // Extract status codes from tests
+    const statusCodes = extractStatusCodesFromTests(item);
+    // Handle responses
+    if (statusCodes.length > 0) {
+        const responses = {};
+        statusCodes.forEach((code) => {
+            responses[code.toString()] = {
+                description: 'Successful response',
+                content: {
+                    'application/json': {},
+                },
+            };
+        });
+        if (pathItem[method]) {
+            pathItem[method].responses = responses;
+        }
+    }
+    else if (item.response && item.response.length > 0) {
+        const firstResponse = item.response[0];
+        const statusCode = firstResponse.code || 200;
+        if (pathItem[method]) {
+            pathItem[method].responses = {
+                [statusCode.toString()]: {
+                    description: firstResponse.status || 'Successful response',
+                    content: {
+                        'application/json': {},
+                    },
+                },
+            };
+        }
+    }
+    else {
+        if (pathItem[method]) {
+            pathItem[method].responses = {
+                '200': {
+                    description: 'Successful response',
+                    content: {
+                        'application/json': {},
+                    },
+                },
+            };
+        }
+    }
+    return { paths, components };
+}
+// Helper function to parse parameters from the description if it is markdown
+function parseParametersFromDescription(description) {
+    const lines = description.split('\n');
+    let inTable = false;
+    const tableLines = [];
+    const descriptionLines = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Detect the start of the table
+        if (line.trim().startsWith('|')) {
+            // Remove any preceding headers or empty lines before the table
+            while (descriptionLines.length > 0 &&
+                (descriptionLines[descriptionLines.length - 1].trim() === '' ||
+                    descriptionLines[descriptionLines.length - 1].trim().startsWith('#'))) {
+                descriptionLines.pop();
+            }
+            // Start collecting table lines
+            inTable = true;
+        }
+        if (inTable) {
+            tableLines.push(line);
+            // Detect the end of the table (any line that doesn't start with '|', excluding the alignment line)
+            if (!line.trim().startsWith('|') && !line.trim().match(/^-+$/)) {
+                inTable = false;
+            }
+        }
+        else {
+            descriptionLines.push(line);
+        }
+    }
+    const tableMarkdown = tableLines.join('\n');
+    const parsedTable = parseMdTable(tableMarkdown);
+    const parametersFromTable = Object.values(parsedTable).map((paramData) => {
+        const paramIn = paramData.object;
+        const param = {
+            name: paramData.name,
+            in: paramIn,
+            description: paramData.description,
+            required: paramData.required === 'true',
+            schema: {
+                type: paramData.type,
+            },
+        };
+        if (paramData.example) {
+            param.example = paramData.example;
+        }
+        return param;
+    });
+    const descriptionWithoutTable = descriptionLines.join('\n');
+    return { descriptionWithoutTable, parametersFromTable };
+}
+// Instead of using regex with \s*, let's split this into two steps
+function extractOperationInfo(name) {
+    if (!name)
+        return { operationId: undefined, summary: undefined };
+    // First check if the string ends with something in brackets
+    const match = name.match(/\[([^[\]]{0,1000})\]$/);
+    if (!match)
+        return { operationId: undefined, summary: name };
+    // Get the operation ID from inside brackets
+    const operationId = match[1];
+    // Trim the brackets part from the end using string operations instead of regex
+    const lastBracketIndex = name.lastIndexOf('[');
+    const summary = name.substring(0, lastBracketIndex).trim();
+    return { operationId, summary };
+}

package/dist/helpers/licenseContactHelper.d.ts

@@ -0,0 +1,14 @@
+import type { OpenAPIV3_1 } from '@scalar/openapi-types';
+import type { PostmanCollection } from '../types.js';
+type InfoResult = {
+    license?: OpenAPIV3_1.LicenseObject;
+    contact?: OpenAPIV3_1.ContactObject;
+};
+/**
+ * Processes the license and contact information from a Postman Collection.
+ * This function checks for license and contact related variables in the collection
+ * and creates corresponding OpenAPI License and Contact Objects if the information is present.
+ */
+export declare function processLicenseAndContact(collection: PostmanCollection): InfoResult;
+export {};
+//# sourceMappingURL=licenseContactHelper.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"licenseContactHelper.d.ts","sourceRoot":"","sources":["../../src/helpers/licenseContactHelper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAExD,OAAO,KAAK,EAAE,iBAAiB,EAAY,MAAM,UAAU,CAAA;AAe3D,KAAK,UAAU,GAAG;IAChB,OAAO,CAAC,EAAE,WAAW,CAAC,aAAa,CAAA;IACnC,OAAO,CAAC,EAAE,WAAW,CAAC,aAAa,CAAA;CACpC,CAAA;AAmDD;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,iBAAiB,GAC5B,UAAU,CAmBZ"}

package/dist/helpers/licenseContactHelper.js

@@ -0,0 +1,73 @@
+// Constants for variable keys
+const VARIABLE_KEYS = {
+    LICENSE: {
+        NAME: 'license.name',
+        URL: 'license.url',
+    },
+    CONTACT: {
+        NAME: 'contact.name',
+        URL: 'contact.url',
+        EMAIL: 'contact.email',
+    },
+};
+/**
+ * Finds a specific variable in the collection by its key
+ */
+function findVariable(collection, key) {
+    return collection.variable?.find((v) => v.key === key);
+}
+/**
+ * Processes license information from collection variables
+ */
+function processLicense(collection) {
+    const nameVar = findVariable(collection, VARIABLE_KEYS.LICENSE.NAME);
+    if (!nameVar?.value || typeof nameVar.value !== 'string')
+        return undefined;
+    const urlVar = findVariable(collection, VARIABLE_KEYS.LICENSE.URL);
+    return {
+        name: nameVar.value,
+        ...(urlVar?.value &&
+            typeof urlVar.value === 'string' && { url: urlVar.value }),
+    };
+}
+/**
+ * Processes contact information from collection variables
+ */
+function processContact(collection) {
+    const nameVar = findVariable(collection, VARIABLE_KEYS.CONTACT.NAME);
+    const urlVar = findVariable(collection, VARIABLE_KEYS.CONTACT.URL);
+    const emailVar = findVariable(collection, VARIABLE_KEYS.CONTACT.EMAIL);
+    if (!nameVar?.value && !urlVar?.value && !emailVar?.value)
+        return undefined;
+    return {
+        ...(nameVar?.value &&
+            typeof nameVar.value === 'string' && { name: nameVar.value }),
+        ...(urlVar?.value &&
+            typeof urlVar.value === 'string' && { url: urlVar.value }),
+        ...(emailVar?.value &&
+            typeof emailVar.value === 'string' && { email: emailVar.value }),
+    };
+}
+/**
+ * Processes the license and contact information from a Postman Collection.
+ * This function checks for license and contact related variables in the collection
+ * and creates corresponding OpenAPI License and Contact Objects if the information is present.
+ */
+export function processLicenseAndContact(collection) {
+    try {
+        const result = {};
+        const license = processLicense(collection);
+        if (license) {
+            result.license = license;
+        }
+        const contact = processContact(collection);
+        if (contact) {
+            result.contact = contact;
+        }
+        return result;
+    }
+    catch (error) {
+        console.error('Error processing license and contact information:', error);
+        throw error;
+    }
+}

package/dist/helpers/logoHelper.d.ts

@@ -0,0 +1,13 @@
+import type { PostmanCollection } from '../types.js';
+/**
+ * Processes logo information from a Postman Collection.
+ * This function extracts logo-related variables from the collection
+ * and constructs an object with logo properties.
+ */
+export declare function processLogo(postmanCollection: PostmanCollection): {
+    url: string;
+    backgroundColor: string;
+    altText: string;
+    href: string;
+} | null;
+//# sourceMappingURL=logoHelper.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logoHelper.d.ts","sourceRoot":"","sources":["../../src/helpers/logoHelper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAEjD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,iBAAiB,EAAE,iBAAiB;;;;;SAoB/D"}

package/dist/helpers/logoHelper.js

@@ -0,0 +1,24 @@
+/**
+ * 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;
+    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,
+    };
+}

package/dist/helpers/md-utils.d.ts

@@ -0,0 +1,6 @@
+import type { TableObject } from '../types.js';
+/**
+ * Parses a Markdown table and returns an object representation.
+ */
+export declare function parseMdTable(md: string): TableObject;
+//# sourceMappingURL=md-utils.d.ts.map

package/dist/helpers/md-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"md-utils.d.ts","sourceRoot":"","sources":["../../src/helpers/md-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,WAAW,EAAE,MAAM,UAAU,CAAA;AAWtD;;GAEG;AACH,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,WAAW,CAoCpD"}

package/dist/helpers/md-utils.js

@@ -0,0 +1,40 @@
+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 (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;
+        }
+        return accTable;
+    }, {});
+    return tableObj;
+}

package/dist/helpers/parameterHelpers.d.ts

@@ -0,0 +1,12 @@
+import type { OpenAPIV3_1 } from '@scalar/openapi-types';
+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[];
+/**
+ * Creates an OpenAPI parameter object from a Postman parameter.
+ */
+export declare function createParameterObject(param: any, paramIn: 'query' | 'path' | 'header'): OpenAPIV3_1.ParameterObject;
+//# sourceMappingURL=parameterHelpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parameterHelpers.d.ts","sourceRoot":"","sources":["../../src/helpers/parameterHelpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAExD,OAAO,KAAK,EAAU,OAAO,EAAE,MAAM,UAAU,CAAA;AAG/C;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,OAAO,GACf,WAAW,CAAC,eAAe,EAAE,CA4D/B;AAsBD;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,GAAG,EACV,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,GACnC,WAAW,CAAC,eAAe,CAmC7B"}

package/dist/helpers/parameterHelpers.js

@@ -0,0 +1,109 @@
+import { inferSchemaType } from './schemaHelpers.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) {
+    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');
+            if (paramObj.name) {
+                parameterMap.set(paramObj.name, paramObj);
+            }
+        });
+    }
+    // Process path parameters
+    if (url.variable) {
+        url.variable.forEach((param) => {
+            const paramObj = createParameterObject(param, 'path');
+            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');
+            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;
+}
+/**
+ * Creates an OpenAPI parameter object from a Postman parameter.
+ */
+export function createParameterObject(param, paramIn) {
+    const parameter = {
+        name: param.key || '',
+        in: paramIn,
+        description: param.description,
+    };
+    // 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) {
+        parameter.example = param.value;
+        parameter.schema = inferSchemaType(param.value);
+    }
+    else {
+        parameter.schema = { type: 'string' }; // Default to string if no value is provided
+    }
+    return parameter;
+}

package/dist/helpers/requestBodyHelpers.d.ts

@@ -0,0 +1,8 @@
+import type { OpenAPIV3_1 } from '@scalar/openapi-types';
+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;
+//# sourceMappingURL=requestBodyHelpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"requestBodyHelpers.d.ts","sourceRoot":"","sources":["../../src/helpers/requestBodyHelpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAExD,OAAO,KAAK,EAAiB,WAAW,EAAuB,MAAM,UAAU,CAAA;AAI/E;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,WAAW,GAChB,WAAW,CAAC,iBAAiB,CAqB/B"}

package/dist/helpers/requestBodyHelpers.js

@@ -0,0 +1,79 @@
+import { processFormDataSchema } from './formDataHelpers.js';
+import { createParameterObject } from './parameterHelpers.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) {
+    const requestBody = {
+        content: {},
+    };
+    if (body.mode === 'raw') {
+        handleRawBody(body, requestBody);
+        return requestBody;
+    }
+    if (body.mode === 'formdata' && body.formdata) {
+        handleFormDataBody(body.formdata, requestBody);
+        return requestBody;
+    }
+    if (body.mode === 'urlencoded' && body.urlencoded) {
+        handleUrlEncodedBody(body.urlencoded, requestBody);
+        return requestBody;
+    }
+    return requestBody;
+}
+function handleRawBody(body, requestBody) {
+    try {
+        const jsonBody = JSON.parse(body.raw || '');
+        requestBody.content = {
+            'application/json': {
+                schema: {
+                    type: 'object',
+                    examples: { default: { value: jsonBody } },
+                },
+            },
+        };
+    }
+    catch (error) {
+        requestBody.content = {
+            'text/plain': {
+                schema: {
+                    type: 'string',
+                    examples: [body.raw],
+                },
+            },
+        };
+    }
+}
+function handleFormDataBody(formdata, requestBody) {
+    requestBody.content = {
+        'multipart/form-data': {
+            schema: processFormDataSchema(formdata),
+        },
+    };
+}
+function handleUrlEncodedBody(urlencoded, requestBody) {
+    const schema = {
+        type: 'object',
+        properties: {},
+        required: [],
+    };
+    urlencoded.forEach((item) => {
+        if (schema.properties) {
+            const paramObject = createParameterObject(item, 'query');
+            schema.properties[item.key] = {
+                type: 'string',
+                examples: [item.value],
+                description: paramObject.description,
+            };
+            if (paramObject.required) {
+                schema.required?.push(item.key);
+            }
+        }
+    });
+    requestBody.content = {
+        'application/x-www-form-urlencoded': {
+            schema,
+        },
+    };
+}

package/dist/helpers/responseHelpers.d.ts

@@ -0,0 +1,9 @@
+import type { OpenAPIV3_1 } from '@scalar/openapi-types';
+import type { Response } from '../types.js';
+/**
+ * Extracts and converts Postman response objects to OpenAPI response objects.
+ * Processes response status codes, descriptions, headers, and body content,
+ * inferring schemas from example responses when possible.
+ */
+export declare function extractResponses(responses: Response[]): OpenAPIV3_1.ResponsesObject;
+//# sourceMappingURL=responseHelpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"responseHelpers.d.ts","sourceRoot":"","sources":["../../src/helpers/responseHelpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAExD,OAAO,KAAK,EAAc,QAAQ,EAAE,MAAM,UAAU,CAAA;AAGpD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,QAAQ,EAAE,GACpB,WAAW,CAAC,eAAe,CAsB7B"}