@scalar/oas-utils 0.1.17 → 0.2.1

package/dist/spec-getters/getExampleFromSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getExampleFromSchema.d.ts","sourceRoot":"","sources":["../../src/spec-getters/getExampleFromSchema.ts"],"names":[],"mappings":"AAsCA;;GAEG;AACH,eAAO,MAAM,oBAAoB,WACvB,OAAO,MAAM,EAAE,GAAG,CAAC,YACjB;IACR;;;QAGI;IACJ,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;OAGG;IACH,GAAG,CAAC,EAAE,OAAO,CAAA;IACb;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;IACvB;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,MAAM,EAAE,GAAG,CAAC,CAAA;IAC/B;;OAEG;IACH,8BAA8B,CAAC,EAAE,OAAO,CAAA;CACzC,UACM,MAAM,iBACE,OAAO,MAAM,EAAE,GAAG,CAAC,SAC3B,MAAM,KACZ,GAkSF,CAAA"}

package/dist/spec-getters/getExampleFromSchema.js

@@ -0,0 +1,246 @@
+/**
+ * We can use the `format` to generate some random values.
+ */
+function guessFromFormat(schema, fallback = '') {
+    const exampleValues = {
+        // 'date-time': '1970-01-01T00:00:00Z',
+        'date-time': new Date().toISOString(),
+        // 'date': '1970-01-01',
+        'date': new Date().toISOString().split('T')[0],
+        'email': 'hello@example.com',
+        'hostname': 'example.com',
+        // https://tools.ietf.org/html/rfc6531#section-3.3
+        'idn-email': 'jane.doe@example.com',
+        // https://tools.ietf.org/html/rfc5890#section-2.3.2.3
+        'idn-hostname': 'example.com',
+        'ipv4': '127.0.0.1',
+        'ipv6': '51d4:7fab:bfbf:b7d7:b2cb:d4b4:3dad:d998',
+        'iri-reference': '/entitiy/1',
+        // https://tools.ietf.org/html/rfc3987
+        'iri': 'https://example.com/entity/123',
+        'json-pointer': '/nested/objects',
+        'password': 'super-secret',
+        'regex': '/[a-z]/',
+        // https://tools.ietf.org/html/draft-handrews-relative-json-pointer-01
+        'relative-json-pointer': '1/nested/objects',
+        // full-time in https://tools.ietf.org/html/rfc3339#section-5.6
+        // 'time': '00:00:00Z',
+        'time': new Date().toISOString().split('T')[1].split('.')[0],
+        // either a URI or relative-reference https://tools.ietf.org/html/rfc3986#section-4.1
+        'uri-reference': '../folder',
+        'uri-template': 'https://example.com/{id}',
+        'uri': 'https://example.com',
+        'uuid': '123e4567-e89b-12d3-a456-426614174000',
+    };
+    return exampleValues[schema.format] ?? fallback;
+}
+/**
+ * This function takes a properties object and generates an example response content.
+ */
+const getExampleFromSchema = (schema, options, level = 0, parentSchema, name) => {
+    // Break an infinite loop
+    if (level > 5) {
+        return null;
+    }
+    // Sometimes, we just want the structure and no values.
+    // But if `emptyString` is  set, we do want to see some values.
+    const makeUpRandomData = !!options?.emptyString;
+    // Check if the property is read-only
+    if (options?.mode === 'write' && schema.readOnly) {
+        return undefined;
+    }
+    // Check if the property is write-only
+    if (options?.mode === 'read' && schema.writeOnly) {
+        return undefined;
+    }
+    // Use given variables as values
+    if (schema['x-variable']) {
+        const value = options?.variables?.[schema['x-variable']];
+        // Return the value if it’s defined
+        if (value !== undefined) {
+            // Type-casting
+            if (schema.type === 'number' || schema.type === 'integer') {
+                return parseInt(value, 10);
+            }
+            return value;
+        }
+    }
+    // Use the first example, if there’s an array
+    if (Array.isArray(schema.examples) && schema.examples.length > 0) {
+        return schema.examples[0];
+    }
+    // Use an example, if there’s one
+    if (schema.example !== undefined) {
+        return schema.example;
+    }
+    // Use a default value, if there’s one
+    if (schema.default !== undefined) {
+        return schema.default;
+    }
+    // enum: [ 'available', 'pending', 'sold' ]
+    if (schema.enum !== undefined) {
+        return schema.enum[0];
+    }
+    // Check if the property is required
+    const isObjectOrArray = schema.type === 'object' || schema.type === 'array';
+    if (!isObjectOrArray && options?.omitEmptyAndOptionalProperties === true) {
+        const isRequired = schema.required === true ||
+            parentSchema?.required === true ||
+            parentSchema?.required?.includes(name ?? schema.name);
+        if (!isRequired) {
+            return undefined;
+        }
+    }
+    // Object
+    if (schema.type === 'object' || schema.properties !== undefined) {
+        const response = {};
+        // Regular properties
+        if (schema.properties !== undefined) {
+            Object.keys(schema.properties).forEach((propertyName) => {
+                const property = schema.properties[propertyName];
+                const propertyXmlTagName = options?.xml ? property.xml?.name : undefined;
+                response[propertyXmlTagName ?? propertyName] = getExampleFromSchema(property, options, level + 1, schema, propertyName);
+                if (typeof response[propertyXmlTagName ?? propertyName] === 'undefined') {
+                    delete response[propertyXmlTagName ?? propertyName];
+                }
+            });
+        }
+        if (schema.anyOf !== undefined) {
+            Object.assign(response, getExampleFromSchema(schema.anyOf[0]), options, level + 1);
+        }
+        else if (schema.oneOf !== undefined) {
+            Object.assign(response, getExampleFromSchema(schema.oneOf[0]), options, level + 1);
+        }
+        else if (schema.allOf !== undefined) {
+            Object.assign(response, ...schema.allOf
+                .map((item) => getExampleFromSchema(item, options, level + 1, schema))
+                .filter((item) => item !== undefined));
+        }
+        // Merge additionalProperties
+        if (schema.additionalProperties !== undefined &&
+            schema.additionalProperties !== false) {
+            const additionalSchema = getExampleFromSchema(schema.additionalProperties, options, level + 1);
+            // Merge objects, but not arrays
+            if (additionalSchema &&
+                typeof additionalSchema === 'object' &&
+                !Array.isArray(additionalSchema)) {
+                return {
+                    ...response,
+                    ...getExampleFromSchema(schema.additionalProperties, options, level + 1),
+                };
+            }
+            // Add an example for nullable properties
+            if (additionalSchema === null) {
+                return null;
+            }
+            // Otherwise, add an example of key-value pair
+            const additionalProperties = getExampleFromSchema(schema.additionalProperties, {
+                ...options,
+                // Let’s just add the additionalProperties, even if they are optional.
+                omitEmptyAndOptionalProperties: false,
+            }, level + 1);
+            return {
+                ...response,
+                ...(additionalProperties === undefined
+                    ? {}
+                    : { '{{key}}': additionalProperties }),
+            };
+        }
+        return response;
+    }
+    // Array
+    if (schema.type === 'array' || schema.items !== undefined) {
+        const itemsXmlTagName = schema?.items?.xml?.name;
+        const wrapItems = !!(options?.xml && schema.xml?.wrapped && itemsXmlTagName);
+        if (schema.example !== undefined) {
+            return wrapItems ? { [itemsXmlTagName]: schema.example } : schema.example;
+        }
+        // Check whether the array has a anyOf, oneOf, or allOf rule
+        if (schema.items) {
+            // Check for all those rules
+            const rules = ['anyOf', 'oneOf', 'allOf'];
+            for (const rule of rules) {
+                // Skip early if the rule is not defined
+                if (!schema.items[rule]) {
+                    continue;
+                }
+                // Otherwise generate examples for the rule
+                const schemas = ['anyOf', 'oneOf'].includes(rule)
+                    ? // Use the first item only
+                        schema.items[rule].slice(0, 1)
+                    : // Use all items
+                        schema.items[rule];
+                const exampleFromRule = schemas
+                    .map((item) => getExampleFromSchema(item, options, level + 1, schema))
+                    .filter((item) => item !== undefined);
+                return wrapItems
+                    ? [{ [itemsXmlTagName]: exampleFromRule }]
+                    : exampleFromRule;
+            }
+        }
+        if (schema.items?.type) {
+            const exampleFromSchema = getExampleFromSchema(schema.items, options, level + 1);
+            return wrapItems
+                ? [{ [itemsXmlTagName]: exampleFromSchema }]
+                : [exampleFromSchema];
+        }
+        return [];
+    }
+    const exampleValues = {
+        string: makeUpRandomData
+            ? guessFromFormat(schema, options?.emptyString)
+            : '',
+        boolean: true,
+        integer: schema.min ?? 1,
+        number: schema.min ?? 1,
+        array: [],
+    };
+    if (schema.type !== undefined && exampleValues[schema.type] !== undefined) {
+        return exampleValues[schema.type];
+    }
+    // Check if property has the `oneOf` key
+    if (Array.isArray(schema.oneOf) && schema.oneOf.length > 0) {
+        // Get the first item from the `oneOf` array
+        const firstOneOfItem = schema.oneOf[0];
+        // Return an example for the first item
+        return getExampleFromSchema(firstOneOfItem, options, level + 1);
+    }
+    // Check if schema has the `allOf` key
+    if (Array.isArray(schema.allOf)) {
+        let example = null;
+        // Loop through all `allOf` schemas
+        schema.allOf.forEach((allOfItem) => {
+            // Return an example from the schema
+            const newExample = getExampleFromSchema(allOfItem, options, level + 1);
+            // Merge or overwrite the example
+            example =
+                typeof newExample === 'object' && typeof example === 'object'
+                    ? {
+                        ...(example ?? {}),
+                        ...newExample,
+                    }
+                    : Array.isArray(newExample) && Array.isArray(example)
+                        ? [...(example ?? {}), ...newExample]
+                        : newExample;
+        });
+        return example;
+    }
+    // Check if schema is a union type
+    if (Array.isArray(schema.type)) {
+        // Return null if the type is nullable
+        if (schema.type.includes('null')) {
+            return null;
+        }
+        // Return an example for the first type in the union
+        const exampleValue = exampleValues[schema.type[0]];
+        if (exampleValue !== undefined) {
+            return exampleValue;
+        }
+    }
+    // Warn if the type is unknown …
+    console.warn(`[getExampleFromSchema] Unknown property type "${schema.type}".`);
+    // … and just return null for now.
+    return null;
+};
+
+export { getExampleFromSchema };

package/dist/{getParametersFromOperation.d.ts → spec-getters/getParametersFromOperation.d.ts}

@@ -1,4 +1,4 @@
-import type { BaseParameter, TransformedOperation } from './types';
+import type { BaseParameter, TransformedOperation } from '../types';
 /**
  * Get the query parameters from an operation.
  *

package/dist/spec-getters/getParametersFromOperation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getParametersFromOperation.d.ts","sourceRoot":"","sources":["../../src/spec-getters/getParametersFromOperation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAGnE;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,oBAAoB,EAC/B,KAAK,EAAE,OAAO,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,UAAU,GAAG,MAAM,EACnE,YAAY,GAAE,OAAc,GAC3B,aAAa,EAAE,CAkCjB"}

package/dist/spec-getters/getParametersFromOperation.js

@@ -0,0 +1,44 @@
+import { getExampleFromSchema } from './getExampleFromSchema.js';
+
+/**
+ * Get the query parameters from an operation.
+ *
+ * Example: [ { name: 'foobar', value: '' } ]
+ *
+ * - OpenAPI 3.x: Possible values are “query”, “header”, “path” or “cookie”.
+ * - Swagger 2.0: Possible values are "query", "header", "path", "formData" or "body".
+ */
+function getParametersFromOperation(operation, where, requiredOnly = true) {
+    const parameters = [
+        ...(operation.pathParameters || []),
+        ...(operation.information?.parameters || []),
+    ];
+    const params = parameters
+        // query, path, header, cookie?
+        .filter((parameter) => parameter.in === where)
+        // don’t add optional parameters
+        .filter((parameter) => (requiredOnly && parameter.required) || !requiredOnly)
+        // transform them
+        .map((parameter) => ({
+        name: parameter.name,
+        description: parameter.description ?? null,
+        value: parameter.example
+            ? parameter.example
+            : parameter.schema
+                ? getExampleFromSchema(parameter.schema, { mode: 'write' })
+                : '',
+        required: parameter.required ?? false,
+        enabled: parameter.required ?? false,
+    }));
+    return params.sort((a, b) => {
+        if (a.required && !b.required) {
+            return -1; // Move a up if a is required and b is not
+        }
+        else if (!a.required && b.required) {
+            return 1; // Move b up if b is required and a is not
+        }
+        return 0; // Keep original order if both have the same required status
+    });
+}
+
+export { getParametersFromOperation };

package/dist/{getRequestBodyFromOperation.d.ts → spec-getters/getRequestBodyFromOperation.d.ts}

@@ -1,4 +1,4 @@
-import type { ContentType, TransformedOperation } from './types';
+import type { ContentType, TransformedOperation } from '../types';
 /**
  * Get the request body from the operation.
  */

package/dist/spec-getters/getRequestBodyFromOperation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getRequestBodyFromOperation.d.ts","sourceRoot":"","sources":["../../src/spec-getters/getRequestBodyFromOperation.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAIjE;;GAEG;AACH,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,oBAAoB,EAC/B,kBAAkB,CAAC,EAAE,MAAM,GAAG,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA6NrC"}

package/dist/spec-getters/getRequestBodyFromOperation.js

@@ -0,0 +1,199 @@
+import { json2xml } from '../helpers/json2xml.js';
+import { normalizeMimeTypeObject } from '../helpers/normalizeMimeTypeObject.js';
+import { prettyPrintJson } from '../helpers/prettyPrintJson.js';
+import { getExampleFromSchema } from './getExampleFromSchema.js';
+import { getParametersFromOperation } from './getParametersFromOperation.js';
+
+/**
+ * Get the request body from the operation.
+ */
+function getRequestBodyFromOperation(operation, selectedExampleKey) {
+    // Define all supported mime types
+    const mimeTypes = [
+        'application/json',
+        'application/octet-stream',
+        'application/x-www-form-urlencoded',
+        'application/xml',
+        'multipart/form-data',
+        'text/plain',
+    ];
+    // Get the content object from the operation
+    const originalContent = operation.information?.requestBody?.content;
+    const content = normalizeMimeTypeObject(originalContent);
+    // Find the first mime type that is supported
+    const mimeType = mimeTypes.find((currentMimeType) => !!content?.[currentMimeType]);
+    /** Examples */
+    const examples = content?.['application/json']?.examples;
+    // Let’s use the first example
+    const selectedExample = (examples ?? {})?.[selectedExampleKey ?? Object.keys(examples ?? {})[0]];
+    if (selectedExample) {
+        return {
+            postData: {
+                mimeType: 'application/json',
+                text: prettyPrintJson(selectedExample?.value),
+            },
+        };
+    }
+    /**
+     * Body Parameters (Swagger 2.0)
+     *
+     * ”The payload that's appended to the HTTP request. Since there can only be one payload, there can only
+     * be one body parameter. The name of the body parameter has no effect on the parameter itself and is used
+     * for documentation purposes only. Since Form parameters are also in the payload, body and form
+     * parameters cannot exist together for the same operation.”
+     */
+    const bodyParameters = getParametersFromOperation(operation, 'body', false);
+    if (bodyParameters.length > 0) {
+        return {
+            postData: {
+                mimeType: 'application/json',
+                text: prettyPrintJson(bodyParameters[0].value),
+            },
+        };
+    }
+    /**
+     * FormData Parameters (Swagger 2.0)
+     *
+     * “Form - Used to describe the payload of an HTTP request when either application/x-www-form-urlencoded,
+     * multipart/form-data or both are used as the content type of the request (in Swagger's definition, the
+     * consumes property of an operation). This is the only parameter type that can be used to send files,
+     * thus supporting the file type. Since form parameters are sent in the payload, they cannot be declared
+     * together with a body parameter for the same operation. Form parameters have a different format based on
+     * the content-type used (for further details, consult http://www.w3.org/TR/html401/interact/forms.html#h-17.13.4):
+     * - application/x-www-form-urlencoded - Similar to the format of Query parameters but as a payload.
+     *   For example, foo=1&bar=swagger - both foo and bar are form parameters. This is normally used for simple
+     *   parameters that are being transferred.
+     * - multipart/form-data - each parameter takes a section in the payload with an internal header.
+     *   For example, for the header Content-Disposition: form-data; name="submit-name" the name of the parameter is
+     *   submit-name. This type of form parameters is more commonly used for file transfers.”
+     */
+    const formDataParameters = getParametersFromOperation(operation, 'formData', false);
+    if (formDataParameters.length > 0) {
+        return {
+            postData: {
+                mimeType: 'application/x-www-form-urlencoded',
+                params: formDataParameters.map((parameter) => ({
+                    name: parameter.name,
+                    value: parameter.value,
+                })),
+            },
+        };
+    }
+    // If no mime type is supported, exit early
+    if (!mimeType) {
+        return {
+            postData: undefined,
+        };
+    }
+    // Get the request body object for the mime type
+    const requestBodyObject = content?.[mimeType];
+    // Define the appropriate Content-Type headers
+    const headers = [
+        {
+            name: 'Content-Type',
+            value: mimeType,
+        },
+    ];
+    // Get example from operation
+    const example = requestBodyObject?.example
+        ? requestBodyObject?.example
+        : undefined;
+    // JSON
+    if (mimeType === 'application/json') {
+        const exampleFromSchema = requestBodyObject?.schema
+            ? getExampleFromSchema(requestBodyObject?.schema, {
+                mode: 'write',
+                omitEmptyAndOptionalProperties: true,
+            })
+            : null;
+        const body = example ?? exampleFromSchema;
+        return {
+            headers,
+            postData: {
+                mimeType: mimeType,
+                text: typeof body === 'string' ? body : JSON.stringify(body, null, 2),
+            },
+        };
+    }
+    // XML
+    if (mimeType === 'application/xml') {
+        const exampleFromSchema = requestBodyObject?.schema
+            ? getExampleFromSchema(requestBodyObject?.schema, {
+                xml: true,
+                mode: 'write',
+                omitEmptyAndOptionalProperties: true,
+            })
+            : null;
+        return {
+            headers,
+            postData: {
+                mimeType: mimeType,
+                text: example ?? json2xml(exampleFromSchema, '  '),
+            },
+        };
+    }
+    // Binary data
+    if (mimeType === 'application/octet-stream') {
+        return {
+            headers,
+            postData: {
+                mimeType: mimeType,
+                text: 'BINARY',
+            },
+        };
+    }
+    // Plain text
+    if (mimeType === 'text/plain') {
+        const exampleFromSchema = requestBodyObject?.schema
+            ? getExampleFromSchema(requestBodyObject?.schema, {
+                xml: true,
+                mode: 'write',
+                omitEmptyAndOptionalProperties: true,
+            })
+            : null;
+        return {
+            headers,
+            postData: {
+                mimeType: mimeType,
+                text: example ?? exampleFromSchema ?? '',
+            },
+        };
+    }
+    // URL encoded data
+    if (mimeType === 'application/x-www-form-urlencoded') {
+        return {
+            headers,
+            postData: {
+                mimeType: mimeType,
+                // TODO: We have an object, but how do we get that kind of array from the object?
+                // Don’t forget to include nested properties … :|
+                // params: [
+                //   {
+                //     name: 'foo',
+                //     value: 'bar',
+                //   },
+                // ],
+            },
+        };
+    }
+    // URL encoded data
+    if (mimeType === 'multipart/form-data') {
+        return {
+            headers,
+            postData: {
+                mimeType: mimeType,
+                // TODO: We have an object, but how do we get that kind of array from the object?
+                // Don’t forget to include nested properties … :|
+                // params: [
+                //   {
+                //     name: 'foo',
+                //     value: 'bar',
+                //   },
+                // ],
+            },
+        };
+    }
+    return undefined;
+}
+
+export { getRequestBodyFromOperation };

package/dist/{getRequestFromOperation.d.ts → spec-getters/getRequestFromOperation.d.ts}

@@ -1,5 +1,9 @@
-import type { HarRequestWithPath, TransformedOperation } from './types';
+import type { HarRequestWithPath, TransformedOperation } from '../types';
 export declare const getRequestFromOperation: (operation: TransformedOperation, options?: {
+    /**
+     * If the path will be URL encoded, you may want to replace {curlyBrackets} with __UNDERSCORES__ to indicate an
+     * variable.
+     */
     replaceVariables?: boolean;
     requiredOnly?: boolean;
 }, selectedExampleKey?: string | number) => Partial<HarRequestWithPath>;

package/dist/spec-getters/getRequestFromOperation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getRequestFromOperation.d.ts","sourceRoot":"","sources":["../../src/spec-getters/getRequestFromOperation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,kBAAkB,EAGlB,oBAAoB,EACrB,MAAM,UAAU,CAAA;AAIjB,eAAO,MAAM,uBAAuB,cACvB,oBAAoB,YACrB;IACR;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB,uBACoB,MAAM,GAAG,MAAM,KACnC,QAAQ,kBAAkB,CA8D5B,CAAA"}

package/dist/spec-getters/getRequestFromOperation.js

@@ -0,0 +1,49 @@
+import { getParametersFromOperation } from './getParametersFromOperation.js';
+import { getRequestBodyFromOperation } from './getRequestBodyFromOperation.js';
+
+const getRequestFromOperation = (operation, options, selectedExampleKey) => {
+    // Replace all variables of the format {something} with the uppercase variable name without the brackets
+    let path = operation.path;
+    // {id} -> 123
+    const pathParameters = getParametersFromOperation(operation, 'path', false);
+    if (pathParameters.length) {
+        const pathVariables = path.match(/{(.*?)}/g);
+        if (pathVariables) {
+            pathVariables.forEach((variable) => {
+                const variableName = variable.replace(/{|}/g, '');
+                if (pathParameters) {
+                    const parameter = pathParameters.find((param) => param.name === variableName);
+                    if (parameter?.value) {
+                        path = path.replace(variable, parameter.value.toString());
+                    }
+                }
+            });
+        }
+    }
+    // {id} -> __ID__
+    if (options?.replaceVariables === true) {
+        const pathVariables = path.match(/{(.*?)}/g);
+        if (pathVariables) {
+            pathVariables.forEach((variable) => {
+                const variableName = variable.replace(/{|}/g, '');
+                path = path.replace(variable, `__${variableName.toUpperCase()}__`);
+            });
+        }
+    }
+    const requestBody = getRequestBodyFromOperation(operation, selectedExampleKey);
+    return {
+        method: operation.httpVerb.toUpperCase(),
+        path,
+        headers: [
+            ...getParametersFromOperation(operation, 'header', options?.requiredOnly),
+            ...(requestBody?.headers ?? []),
+        ],
+        // TODO: Sorry, something is off here and I don’t get it.
+        // @ts-ignore
+        postData: requestBody?.postData,
+        queryString: getParametersFromOperation(operation, 'query', options?.requiredOnly),
+        cookies: getParametersFromOperation(operation, 'cookie', options?.requiredOnly),
+    };
+};
+
+export { getRequestFromOperation };

package/dist/spec-getters/index.d.ts

@@ -0,0 +1,5 @@
+export * from './getExampleFromSchema.js';
+export * from './getParametersFromOperation.js';
+export * from './getRequestBodyFromOperation.js';
+export * from './getRequestFromOperation.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/spec-getters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/spec-getters/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAA;AACtC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,+BAA+B,CAAA;AAC7C,cAAc,2BAA2B,CAAA"}

package/dist/spec-getters/index.js

@@ -0,0 +1,4 @@
+export { getExampleFromSchema } from './getExampleFromSchema.js';
+export { getParametersFromOperation } from './getParametersFromOperation.js';
+export { getRequestBodyFromOperation } from './getRequestBodyFromOperation.js';
+export { getRequestFromOperation } from './getRequestFromOperation.js';

package/dist/transforms/import-spec.d.ts

@@ -0,0 +1,67 @@
+import { type Request } from '../entities/workspace/spec/index.js';
+import type { AnyObject } from '../types';
+/** Import an OpenAPI spec file and convert it to workspace entities */
+export declare const importSpecToWorkspace: (spec: string | AnyObject) => Promise<{
+    tags: {
+        name: string;
+        description?: string | undefined;
+    }[];
+    folders: {
+        name: string;
+        uid: string;
+        childUids: string[];
+        description?: string | undefined;
+    }[];
+    servers: {
+        url: string;
+        uid: string;
+        description?: string | undefined;
+        variables?: Record<string, {
+            default: string;
+            uid: string;
+            enum?: string[] | undefined;
+            description?: string | undefined;
+        }> | null | undefined;
+    }[];
+    requests: Request[];
+    collection: {
+        uid: string;
+        spec: {
+            openapi: string;
+            serverUids: string[];
+            tags: {
+                name: string;
+                description?: string | undefined;
+                externalDocs?: {
+                    url: string;
+                    description?: string | undefined;
+                } | undefined;
+            }[];
+            info?: {
+                title: string;
+                version: string;
+                summary?: string | undefined;
+                description?: string | undefined;
+                termsOfService?: string | undefined;
+                contact?: {
+                    name?: string | undefined;
+                    url?: string | undefined;
+                    email?: string | undefined;
+                } | undefined;
+                license?: {
+                    name: string;
+                    identifier?: string | undefined;
+                    url?: string | undefined;
+                } | undefined;
+            } | undefined;
+            externalDocs?: {
+                url: string;
+                description?: string | undefined;
+            } | undefined;
+        };
+        selectedServerUid: string;
+        childUids: string[];
+    };
+    components: any;
+}>;
+//# sourceMappingURL=import-spec.d.ts.map

package/dist/transforms/import-spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-spec.d.ts","sourceRoot":"","sources":["../../src/transforms/import-spec.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,OAAO,EAAiB,MAAM,2BAA2B,CAAA;AAKvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAWxC,uEAAuE;AACvE,eAAO,MAAM,qBAAqB,SAAgB,MAAM,GAAG,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmJnE,CAAA"}