@skmtc/core 0.28.7 → 0.30.1

package/esm/parse/v3-2/operation/toOperationsV3.js

@@ -0,0 +1,129 @@
+import { toRequestBodyV3 } from '../requestBody/toRequestBodiesV3.js';
+import { toResponsesV3 } from '../response/toResponseV3.js';
+import { toParameterListV3 } from '../parameter/toParameterV3.js';
+import { OasOperation } from '../../../oas/operation/Operation.js';
+import { toPathItemResultV3 } from '../pathItem/toPathItemV3.js';
+import { toPathItemMethod } from '../methods.js';
+import { dropAdditionalOperationsV3 } from '../pathItem/dropAdditionalOperationsV3.js';
+import { warnQuerystringConflictsV3 } from '../parameter/warnQuerystringConflictsV3.js';
+import { toSpecificationExtensionsV3 } from '../specificationExtensions/toSpecificationExtensionsV3.js';
+import { toSecurityRequirementsV3 } from '../securityRequirement/toSecurityRequirement.js';
+import { toExternalDocs } from '../externalDocs/toExternalDocs.js';
+import { toOptionalServersV3 } from '../server/toServerV3.js';
+export const toOperationV3 = ({ operation, operationInfo, stackTrail, context }) => {
+    const { method, path, pathItem } = operationInfo;
+    const { operationId, tags, summary, description, parameters, requestBody, responses, deprecated, security, externalDocs, servers, 
+    // Callbacks are a deliberate non-goal (no out-of-band callback codegen).
+    // Pull it out so it is dropped silently instead of warned as an
+    // unexpected property on every operation that declares one.
+    callbacks: _callbacks, ...skipped } = operation;
+    const extensionFields = toSpecificationExtensionsV3({
+        skipped,
+        parent: operation,
+        context,
+        stackTrail,
+        parentType: 'operation'
+    });
+    const parsedParameters = stackTrail.trace('parameters', st => toParameterListV3({ parameters, stackTrail: st, context }));
+    warnQuerystringConflictsV3({ parameters: parsedParameters, pathItem, stackTrail, context });
+    const parsedRequestBody = stackTrail.trace('requestBody', st => toRequestBodyV3({ requestBody, stackTrail: st, context }));
+    const parsedResponses = stackTrail.trace('responses', st => toResponsesV3({ responses, stackTrail: st, context }));
+    const parsedSecurity = stackTrail.trace('security', st => toSecurityRequirementsV3({ security, stackTrail: st, context }));
+    const parsedExternalDocs = stackTrail.trace('externalDocs', st => toExternalDocs({ externalDocs, stackTrail: st, context }));
+    const parsedServers = stackTrail.trace('servers', st => toOptionalServersV3({ servers, stackTrail: st, context }));
+    return context.withStackTrail(stackTrail, () => new OasOperation({
+        pathItem,
+        path,
+        method,
+        operationId,
+        summary,
+        tags,
+        description,
+        parameters: parsedParameters,
+        requestBody: parsedRequestBody,
+        responses: parsedResponses,
+        deprecated,
+        security: parsedSecurity,
+        externalDocs: parsedExternalDocs,
+        servers: parsedServers,
+        extensionFields
+    }, context));
+};
+export const toOperationsV3 = ({ paths, stackTrail, context }) => {
+    if (!paths) {
+        return [];
+    }
+    return Object.entries(paths).flatMap(([path, pathItem]) => {
+        return stackTrail.trace(path, pathStack => {
+            if (!pathItem) {
+                return [];
+            }
+            const fixedFields = dropAdditionalOperationsV3({ pathItem, stackTrail: pathStack, context });
+            const cleaned = Object.entries(fixedFields).reduce(({ rest, methodObject }, [key, operation]) => {
+                const method = toPathItemMethod(key);
+                if (method) {
+                    const { [method]: _deleted, ...remaining } = rest;
+                    return {
+                        rest: remaining,
+                        methodObject: {
+                            ...methodObject,
+                            [method]: operation
+                        }
+                    };
+                }
+                return { rest, methodObject };
+            }, {
+                rest: fixedFields,
+                methodObject: {}
+            });
+            const pathItemResult = toPathItemResultV3({
+                pathItem: cleaned.rest,
+                stackTrail: pathStack,
+                context
+            });
+            if (!pathItemResult.valid) {
+                return [];
+            }
+            const pathItemObject = pathItemResult.pathItem;
+            return Object.entries(cleaned.methodObject)
+                .map(([method, operation]) => {
+                // Use `pathStack` (the trail with `path` already pushed),
+                // not the outer `stackTrail` — otherwise downstream traces
+                // record paths:<method>:... and lose the actual path
+                // segment, which breaks `OasDocument.removeItem` and the
+                // dependency-ref invalidation it backs.
+                return pathStack.trace(method, st => {
+                    if (!operation) {
+                        return;
+                    }
+                    try {
+                        return toOperationV3({
+                            operation,
+                            operationInfo: {
+                                method: method,
+                                path,
+                                pathItem: pathItemObject
+                            },
+                            stackTrail: st,
+                            context
+                        });
+                    }
+                    catch (error) {
+                        const normalized = error instanceof Error ? error : new Error(String(error));
+                        context.logIssue({
+                            key: method,
+                            parent: operation,
+                            level: 'error',
+                            message: normalized.message,
+                            cause: normalized,
+                            stackTrail: st,
+                            type: 'INVALID_OPERATION'
+                        });
+                        return undefined;
+                    }
+                });
+            })
+                .filter((item) => Boolean(item));
+        });
+    });
+};

package/esm/parse/v3-2/parameter/toParameterV3.d.ts

@@ -0,0 +1,39 @@
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { type OasParameterLocation } from '../../../oas/parameter/parameter-types.js';
+import type { OpenAPIV3 } from 'openapi-types';
+import { OasParameter } from '../../../oas/parameter/Parameter.js';
+import type { OasRef } from '../../../oas/ref/Ref.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToParameterListV3Args = {
+    parameters: (OpenAPIV3.ParameterObject | OpenAPIV3.ReferenceObject)[] | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toParameterListV3: ({ parameters, stackTrail, context }: ToParameterListV3Args) => (OasParameter | OasRef<"parameter">)[] | undefined;
+export type ToParametersV3Args = {
+    parameters: Record<string, OpenAPIV3.ParameterObject | OpenAPIV3.ReferenceObject>;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toParametersV3: ({ parameters, stackTrail, context }: ToParametersV3Args) => Record<string, OasParameter | OasRef<"parameter">>;
+export type ToOptionalParametersV3Args = {
+    parameters: Record<string, OpenAPIV3.ParameterObject | OpenAPIV3.ReferenceObject> | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toOptionalParametersV3: ({ parameters, stackTrail, context }: ToOptionalParametersV3Args) => Record<string, OasParameter | OasRef<"parameter">> | undefined;
+export type ToParameterV3Args = {
+    parameter: OpenAPIV3.ParameterObject | OpenAPIV3.ReferenceObject;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export type ToStyleArgs = {
+    style: string | undefined;
+    location: OasParameterLocation;
+    stackTrail: StackTrail;
+};
+export type ToExplodeArgs = {
+    explode: boolean | undefined;
+    style: string | undefined;
+    stackTrail: StackTrail;
+};

package/esm/parse/v3-2/parameter/toParameterV3.js

@@ -0,0 +1,152 @@
+import { tryParseAt } from '../../../context/tryParseAt.js';
+import { isRef } from '../../../helpers/refFns.js';
+import { oasParameterLocation, oasParameterStyle } from '../../../oas/parameter/parameter-types.js';
+import { toExamplesV3 } from '../example/toExamplesV3.js';
+import { toRefV31 } from '../ref/toRefV31.js';
+import { toOptionalSchemaV3 } from '../schema/toSchemasV3.js';
+import { toOptionalMediaTypeItemsV3 } from '../mediaType/toMediaTypeItemV3.js';
+import { OasParameter } from '../../../oas/parameter/Parameter.js';
+import { toSpecificationExtensionsV3 } from '../specificationExtensions/toSpecificationExtensionsV3.js';
+import * as v from 'valibot';
+export const toParameterListV3 = ({ parameters, stackTrail, context }) => {
+    if (!parameters) {
+        return undefined;
+    }
+    return parameters.flatMap((parameter, index) => {
+        const querystringIssue = toQuerystringIssue(parameter);
+        if (querystringIssue) {
+            context.logIssue({
+                key: `${index}`,
+                parent: parameter,
+                level: 'error',
+                message: querystringIssue,
+                stackTrail,
+                type: 'INVALID_PARAMETER'
+            });
+            return [];
+        }
+        return [
+            stackTrail.trace(`${index}`, st => toParameterV3({ parameter, stackTrail: st, context }))
+        ];
+    });
+};
+/**
+ * A `querystring` parameter describes the whole query string, so it must
+ * carry `content` with exactly one media type, and no `schema`. Returns
+ * the problem, or `undefined` when the parameter is valid or is not a
+ * `querystring` parameter.
+ */
+const toQuerystringIssue = (parameter) => {
+    if (isRef(parameter) || parameter.in !== 'querystring') {
+        return undefined;
+    }
+    if (parameter.schema || Object.keys(parameter.content ?? {}).length !== 1) {
+        return `Parameter '${parameter.name}' in querystring must define content with exactly one media type, and no schema`;
+    }
+    return undefined;
+};
+export const toParametersV3 = ({ parameters, stackTrail, context }) => {
+    const output = {};
+    const entries = Object.entries(parameters);
+    for (const [key, parameter] of entries) {
+        const parsed = tryParseAt({
+            stackTrail,
+            key,
+            context,
+            type: 'INVALID_PARAMETER',
+            parent: parameter,
+            fn: st => toParameterV3({ parameter, stackTrail: st, context })
+        });
+        if (parsed !== undefined) {
+            output[key] = parsed;
+        }
+    }
+    return output;
+};
+export const toOptionalParametersV3 = ({ parameters, stackTrail, context }) => {
+    if (!parameters) {
+        return undefined;
+    }
+    return toParametersV3({ parameters, stackTrail, context });
+};
+const toParameterV3 = ({ parameter, stackTrail, context }) => {
+    if (isRef(parameter)) {
+        return toRefV31({ ref: parameter, refType: 'parameter', stackTrail, context });
+    }
+    const querystringIssue = toQuerystringIssue(parameter);
+    if (querystringIssue) {
+        throw new Error(querystringIssue);
+    }
+    const { name, in: location, description, required, deprecated, allowEmptyValue, allowReserved, schema, example, examples, content, style, explode, ...skipped } = parameter;
+    const extensionFields = toSpecificationExtensionsV3({
+        skipped,
+        parent: parameter,
+        context,
+        stackTrail,
+        parentType: 'parameter'
+    });
+    const parsedLocation = v.parse(oasParameterLocation, location);
+    if (parsedLocation === 'path' && !required) {
+        console.warn(`Path parameters must be required`);
+    }
+    // Set missing 'required' to true for path parameters and false for others
+    const defaultRequired = typeof required === 'undefined' ? (parsedLocation === 'path' ? true : false) : required;
+    const fields = {
+        name,
+        location: parsedLocation,
+        description,
+        required: defaultRequired,
+        deprecated,
+        style: stackTrail.trace('style', st => toStyle({ style, location: parsedLocation, stackTrail: st })),
+        explode: stackTrail.trace('explode', st => toExplode({ explode, style, stackTrail: st })),
+        allowEmptyValue,
+        allowReserved,
+        schema: stackTrail.trace('schema', st => toOptionalSchemaV3({ schema, stackTrail: st, context })),
+        examples: stackTrail.trace('examples', st => toExamplesV3({
+            examples,
+            example,
+            exampleKey: `${name}-${parsedLocation}`,
+            stackTrail: st,
+            context
+        })),
+        content: stackTrail.trace('content', st => toOptionalMediaTypeItemsV3({ content, stackTrail: st, context })),
+        extensionFields
+    };
+    return context.withStackTrail(stackTrail, () => new OasParameter(fields, context));
+};
+const toStyle = ({ style, location, stackTrail }) => {
+    const parsed = v.parse(v.optional(oasParameterStyle), style);
+    if (parsed === 'cookie' && location !== 'cookie') {
+        throw new Error(`Style 'cookie' is only allowed for cookie parameters, not ${location}`);
+    }
+    if (parsed !== undefined) {
+        return parsed;
+    }
+    switch (location) {
+        case 'path':
+        case 'header':
+            return 'simple';
+        case 'query':
+        case 'cookie':
+            return 'form';
+        case 'querystring':
+            // A querystring parameter is serialized by its `content` media type.
+            return undefined;
+        default: {
+            const _exhaustive = location;
+            throw new Error(`Unhandled location: ${_exhaustive}`);
+        }
+    }
+};
+const toExplode = ({ explode, style, stackTrail }) => {
+    if (explode !== undefined) {
+        return explode;
+    }
+    switch (style) {
+        case 'form':
+        case 'cookie':
+            return true;
+        default:
+            return false;
+    }
+};

package/esm/parse/v3-2/parameter/warnQuerystringConflictsV3.d.ts

@@ -0,0 +1,22 @@
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+import type { OasParameter } from '../../../oas/parameter/Parameter.js';
+import type { OasPathItem } from '../../../oas/pathItem/PathItem.js';
+import type { OasRef } from '../../../oas/ref/Ref.js';
+export type WarnQuerystringConflictsV3Args = {
+    parameters: (OasParameter | OasRef<'parameter'>)[] | undefined;
+    pathItem: OasPathItem | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+/**
+ * Logs an `INVALID_PARAMETER` warning on the operation's `parameters` when
+ * the operation and its path item together declare more than one
+ * `querystring` parameter, or a `querystring` parameter alongside an
+ * `in: query` parameter. An operation parameter replaces a path item
+ * parameter with the same name and location. The parameters are kept.
+ *
+ * Only inline parameters are checked: a `$ref` parameter cannot be
+ * resolved while the document is still being parsed.
+ */
+export declare const warnQuerystringConflictsV3: ({ parameters, pathItem, stackTrail, context }: WarnQuerystringConflictsV3Args) => void;

package/esm/parse/v3-2/parameter/warnQuerystringConflictsV3.js

@@ -0,0 +1,39 @@
+/**
+ * Logs an `INVALID_PARAMETER` warning on the operation's `parameters` when
+ * the operation and its path item together declare more than one
+ * `querystring` parameter, or a `querystring` parameter alongside an
+ * `in: query` parameter. An operation parameter replaces a path item
+ * parameter with the same name and location. The parameters are kept.
+ *
+ * Only inline parameters are checked: a `$ref` parameter cannot be
+ * resolved while the document is still being parsed.
+ */
+export const warnQuerystringConflictsV3 = ({ parameters, pathItem, stackTrail, context }) => {
+    const inlineParameters = [...(pathItem?.parameters ?? []), ...(parameters ?? [])].filter((parameter) => !parameter.isRef());
+    const merged = [
+        ...new Map(inlineParameters.map(parameter => [`${parameter.location}:${parameter.name}`, parameter])).values()
+    ];
+    const querystringCount = merged.filter(({ location }) => location === 'querystring').length;
+    if (querystringCount === 0) {
+        return;
+    }
+    const queryNames = merged.filter(({ location }) => location === 'query').map(({ name }) => name);
+    const messages = [
+        querystringCount > 1
+            ? `Operation has ${querystringCount} querystring parameters. At most one is allowed.`
+            : undefined,
+        queryNames.length
+            ? `A querystring parameter must not appear with query parameters (${queryNames.join(', ')}).`
+            : undefined
+    ].filter((message) => Boolean(message));
+    messages.forEach(message => {
+        context.logIssue({
+            key: 'parameters',
+            parent: parameters,
+            level: 'warning',
+            message,
+            stackTrail,
+            type: 'INVALID_PARAMETER'
+        });
+    });
+};

package/esm/parse/v3-2/pathItem/dropAdditionalOperationsV3.d.ts

@@ -0,0 +1,17 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type DropAdditionalOperationsV3Args = {
+    pathItem: OpenAPIV3.PathItemObject;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+/**
+ * Removes the 3.2 `additionalOperations` map from a path item and logs one
+ * `UNSUPPORTED_OPERATION_METHOD` warning per entry, naming the method. The
+ * operations are dropped: no generator renders an arbitrary method yet.
+ *
+ * A value that is not a map (a primitive or an array) stays on the path
+ * item, so the path item parser reports it as a skipped field.
+ */
+export declare const dropAdditionalOperationsV3: ({ pathItem, stackTrail, context }: DropAdditionalOperationsV3Args) => OpenAPIV3.PathItemObject;

package/esm/parse/v3-2/pathItem/dropAdditionalOperationsV3.js

@@ -0,0 +1,34 @@
+/**
+ * Removes the 3.2 `additionalOperations` map from a path item and logs one
+ * `UNSUPPORTED_OPERATION_METHOD` warning per entry, naming the method. The
+ * operations are dropped: no generator renders an arbitrary method yet.
+ *
+ * A value that is not a map (a primitive or an array) stays on the path
+ * item, so the path item parser reports it as a skipped field.
+ */
+export const dropAdditionalOperationsV3 = ({ pathItem, stackTrail, context }) => {
+    // `Object.hasOwn` is false for a primitive path item value, which the
+    // path item parser then reports as a skipped field.
+    if (!Object.hasOwn(pathItem, 'additionalOperations') || !('additionalOperations' in pathItem)) {
+        return pathItem;
+    }
+    const { additionalOperations, ...rest } = pathItem;
+    if (typeof additionalOperations !== 'object' ||
+        additionalOperations === null ||
+        Array.isArray(additionalOperations)) {
+        return pathItem;
+    }
+    stackTrail.trace('additionalOperations', st => {
+        Object.entries(additionalOperations).forEach(([method, operation]) => {
+            context.logIssue({
+                key: method,
+                parent: operation,
+                level: 'warning',
+                message: `Operation method '${method}' in additionalOperations is not supported. The operation is dropped.`,
+                stackTrail: st,
+                type: 'UNSUPPORTED_OPERATION_METHOD'
+            });
+        });
+    });
+    return rest;
+};

package/esm/parse/v3-2/pathItem/toPathItemV3.d.ts

@@ -0,0 +1,23 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasPathItem } from '../../../oas/pathItem/PathItem.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToPathItemV3Args = {
+    pathItem: OpenAPIV3.PathItemObject;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toPathItemV3: ({ pathItem, stackTrail, context }: ToPathItemV3Args) => OasPathItem;
+export type PathItemResult = {
+    valid: true;
+    pathItem: OasPathItem | undefined;
+} | {
+    valid: false;
+};
+/**
+ * Parses a path item's shared fields without letting a throw escape. A
+ * path-level parameter that fails validation (for example `in: body`) logs
+ * one `INVALID_OPERATION` at the path and returns `{ valid: false }`, so
+ * the caller skips that path and keeps the rest.
+ */
+export declare const toPathItemResultV3: ({ pathItem, stackTrail, context }: ToPathItemV3Args) => PathItemResult;

package/esm/parse/v3-2/pathItem/toPathItemV3.js

@@ -0,0 +1,45 @@
+import { toParameterListV3 } from '../parameter/toParameterV3.js';
+import { OasPathItem } from '../../../oas/pathItem/PathItem.js';
+import { toSpecificationExtensionsV3 } from '../specificationExtensions/toSpecificationExtensionsV3.js';
+import { isEmpty } from '../../../helpers/isEmpty.js';
+export const toPathItemV3 = ({ pathItem, stackTrail, context }) => {
+    const { summary, description, parameters, ...skipped } = pathItem;
+    return new OasPathItem({
+        summary,
+        description,
+        parameters: stackTrail.trace('parameters', st => toParameterListV3({ parameters, stackTrail: st, context })),
+        extensionFields: toSpecificationExtensionsV3({
+            skipped,
+            parent: pathItem,
+            context,
+            stackTrail,
+            parentType: 'pathItem'
+        })
+    });
+};
+/**
+ * Parses a path item's shared fields without letting a throw escape. A
+ * path-level parameter that fails validation (for example `in: body`) logs
+ * one `INVALID_OPERATION` at the path and returns `{ valid: false }`, so
+ * the caller skips that path and keeps the rest.
+ */
+export const toPathItemResultV3 = ({ pathItem, stackTrail, context }) => {
+    if (isEmpty(pathItem)) {
+        return { valid: true, pathItem: undefined };
+    }
+    try {
+        return { valid: true, pathItem: toPathItemV3({ pathItem, stackTrail, context }) };
+    }
+    catch (error) {
+        const normalized = error instanceof Error ? error : new Error(String(error));
+        context.logIssueNoKey({
+            parent: pathItem,
+            level: 'error',
+            message: normalized.message,
+            cause: normalized,
+            stackTrail,
+            type: 'INVALID_OPERATION'
+        });
+        return { valid: false };
+    }
+};

package/esm/parse/v3-2/ref/toRefV31.d.ts

@@ -0,0 +1,19 @@
+import type { OpenAPIV3_1 } from 'openapi-types';
+import type { OasRefData } from '../../../oas/ref/ref-types.js';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasRef } from '../../../oas/ref/Ref.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+type ToRefV31Args<T extends OasRefData['refType']> = {
+    ref: OpenAPIV3_1.ReferenceObject;
+    refType: T;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+    /**
+     * Use-site nullability to stamp on the OasRef node. Passed explicitly
+     * by the single-member `oneOf`/`anyOf` collapse for a nullable
+     * reference; omitted everywhere else (a plain `$ref` is non-nullable).
+     */
+    nullable?: boolean;
+};
+export declare const toRefV31: <T extends OasRefData["refType"]>({ ref, refType, stackTrail, context, nullable }: ToRefV31Args<T>) => OasRef<T>;
+export {};

package/esm/parse/v3-2/ref/toRefV31.js

@@ -0,0 +1,10 @@
+import { OasRef } from '../../../oas/ref/Ref.js';
+import { isEmpty } from '../../../helpers/isEmpty.js';
+export const toRefV31 = ({ ref, refType, stackTrail, context, nullable }) => {
+    const { $ref, ...skipped } = ref;
+    if (!isEmpty(skipped)) {
+        context.logSkippedFields({ skipped, parent: ref, parentType: 'ref', stackTrail });
+    }
+    context.registerRef(stackTrail.clone(), $ref);
+    return context.withStackTrail(stackTrail, () => new OasRef({ refType, $ref, nullable }, context));
+};

package/esm/parse/v3-2/requestBody/toRequestBodiesV3.d.ts

@@ -0,0 +1,18 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasRequestBody } from '../../../oas/requestBody/RequestBody.js';
+import type { OasRef } from '../../../oas/ref/Ref.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToRequestBodyV3Args = {
+    requestBody: OpenAPIV3.ReferenceObject | OpenAPIV3.RequestBodyObject | undefined;
+    forceRef?: boolean;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toRequestBodyV3: ({ requestBody, stackTrail, context }: ToRequestBodyV3Args) => OasRequestBody | OasRef<"requestBody"> | undefined;
+export type ToRequestBodiesV3Args = {
+    requestBodies: Record<string, OpenAPIV3.ReferenceObject | OpenAPIV3.RequestBodyObject> | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toRequestBodiesV3: ({ requestBodies, stackTrail, context }: ToRequestBodiesV3Args) => Record<string, OasRequestBody | OasRef<"requestBody">> | undefined;

package/esm/parse/v3-2/requestBody/toRequestBodiesV3.js

@@ -0,0 +1,44 @@
+import { isRef } from '../../../helpers/refFns.js';
+import { toRefV31 } from '../ref/toRefV31.js';
+import { toMediaTypeItemsV3 } from '../mediaType/toMediaTypeItemV3.js';
+import { OasRequestBody } from '../../../oas/requestBody/RequestBody.js';
+import { toSpecificationExtensionsV3 } from '../specificationExtensions/toSpecificationExtensionsV3.js';
+export const toRequestBodyV3 = ({ requestBody, stackTrail, context }) => {
+    if (!requestBody) {
+        return undefined;
+    }
+    if (isRef(requestBody)) {
+        return toRefV31({ ref: requestBody, refType: 'requestBody', stackTrail, context });
+    }
+    const { description, content, required, ...skipped } = requestBody;
+    const extensionFields = toSpecificationExtensionsV3({
+        skipped,
+        parent: requestBody,
+        context,
+        stackTrail,
+        parentType: 'requestBody'
+    });
+    const fields = {
+        description,
+        content: stackTrail.trace('content', st => {
+            return toMediaTypeItemsV3({ content, stackTrail: st, context });
+        }),
+        required,
+        extensionFields
+    };
+    return context.withStackTrail(stackTrail, () => new OasRequestBody(fields, context));
+};
+export const toRequestBodiesV3 = ({ requestBodies, stackTrail, context }) => {
+    if (!requestBodies) {
+        return undefined;
+    }
+    const entries = Object.entries(requestBodies)
+        .map(([key, value]) => {
+        return [
+            key,
+            stackTrail.trace(key, st => toRequestBodyV3({ requestBody: value, stackTrail: st, context }))
+        ];
+    })
+        .filter(([, value]) => Boolean(value));
+    return Object.fromEntries(entries);
+};

package/esm/parse/v3-2/response/toResponseV3.d.ts

@@ -0,0 +1,29 @@
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { OpenAPIV3 } from 'openapi-types';
+import { OasResponse } from '../../../oas/response/Response.js';
+import type { OasRef } from '../../../oas/ref/Ref.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+/** A 3.2 Response Object: the 3.0 shape plus `summary`. */
+export type ResponseObjectV32 = OpenAPIV3.ResponseObject & {
+    summary?: string;
+};
+/** A 3.2 Responses Object: status code to a 3.2 Response Object or a reference. */
+export type ResponsesObjectV32 = Record<string, OpenAPIV3.ReferenceObject | ResponseObjectV32>;
+export type ToResponsesV3Args = {
+    responses: ResponsesObjectV32;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toResponsesV3: ({ responses, stackTrail, context }: ToResponsesV3Args) => Record<string, OasResponse | OasRef<"response">>;
+export type ToOptionalResponsesV3Args = {
+    responses: ResponsesObjectV32 | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toOptionalResponsesV3: ({ responses, stackTrail, context }: ToOptionalResponsesV3Args) => Record<string, OasResponse | OasRef<"response">> | undefined;
+export type ToResponseV3Args = {
+    response: OpenAPIV3.ReferenceObject | ResponseObjectV32;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toResponseV3: ({ response, stackTrail, context }: ToResponseV3Args) => OasResponse | OasRef<"response">;