@skmtc/core 0.29.0 → 0.31.0

package/esm/parse/v3-2/response/toResponseV3.js

@@ -0,0 +1,59 @@
+import { toRefV31 } from '../ref/toRefV31.js';
+import { toHeadersV3 } from '../header/toHeadersV3.js';
+import { toLinksV3 } from '../link/toLinksV3.js';
+import { isRef } from '../../../helpers/refFns.js';
+import { toOptionalMediaTypeItemsV3 } from '../mediaType/toMediaTypeItemV3.js';
+import { OasResponse } from '../../../oas/response/Response.js';
+import { toSpecificationExtensionsV3 } from '../specificationExtensions/toSpecificationExtensionsV3.js';
+import { tryParseAt } from '../../../context/tryParseAt.js';
+import { logBodyMediaTypes } from '../../logBodyMediaTypes.js';
+export const toResponsesV3 = ({ responses, stackTrail, context }) => {
+    const output = {};
+    const entries = Object.entries(responses);
+    for (const [key, value] of entries) {
+        const parsed = tryParseAt({
+            stackTrail,
+            key,
+            context,
+            type: 'INVALID_RESPONSE',
+            parent: value,
+            fn: st => toResponseV3({ response: value, stackTrail: st, context })
+        });
+        if (parsed !== undefined) {
+            output[key] = parsed;
+        }
+    }
+    return output;
+};
+export const toOptionalResponsesV3 = ({ responses, stackTrail, context }) => {
+    if (!responses) {
+        return undefined;
+    }
+    return toResponsesV3({ responses, stackTrail, context });
+};
+export const toResponseV3 = ({ response, stackTrail, context }) => {
+    if (isRef(response)) {
+        return toRefV31({ ref: response, refType: 'response', stackTrail, context });
+    }
+    const { summary, description, headers, links, content, ...skipped } = response;
+    const extensionFields = toSpecificationExtensionsV3({
+        skipped,
+        parent: response,
+        context,
+        stackTrail,
+        parentType: 'response'
+    });
+    const parsedHeaders = stackTrail.trace('headers', st => toHeadersV3({ headers, stackTrail: st, context }));
+    const parsedLinks = stackTrail.trace('links', st => toLinksV3({ links, stackTrail: st, context }));
+    const parsedContent = stackTrail.trace('content', st => toOptionalMediaTypeItemsV3({ content, stackTrail: st, context }));
+    const parsed = context.withStackTrail(stackTrail, () => new OasResponse({
+        summary,
+        description,
+        headers: parsedHeaders,
+        links: parsedLinks,
+        content: parsedContent,
+        extensionFields
+    }, context));
+    logBodyMediaTypes({ content: parsedContent, stackTrail, context });
+    return parsed;
+};

package/esm/parse/v3-2/schema/toSchemasV3.d.ts

@@ -0,0 +1,29 @@
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { OpenAPIV3 } from 'openapi-types';
+import type { OasSchema } from '../../../oas/schema/Schema.js';
+import type { OasRef } from '../../../oas/ref/Ref.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToSchemasV3Args = {
+    schemas: Record<string, OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject>;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toSchemasV3: ({ schemas, stackTrail, context }: ToSchemasV3Args) => Record<string, OasSchema | OasRef<"schema">>;
+export type ToOptionalSchemasV3Args = {
+    schemas: Record<string, OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject> | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toOptionalSchemasV3: ({ schemas, stackTrail, context }: ToOptionalSchemasV3Args) => Record<string, OasSchema | OasRef<"schema">> | undefined;
+export type ToSchemaV3Args = {
+    schema: OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toSchemaV3: ({ schema, stackTrail, context }: ToSchemaV3Args) => OasSchema | OasRef<"schema">;
+export type ToOptionalSchemaV3Args = {
+    schema: OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toOptionalSchemaV3: ({ schema, stackTrail, context }: ToOptionalSchemaV3Args) => OasSchema | OasRef<"schema"> | undefined;

package/esm/parse/v3-2/schema/toSchemasV3.js

@@ -0,0 +1,511 @@
+import { toRefV31 } from '../ref/toRefV31.js';
+import { isRef } from '../../../helpers/refFns.js';
+import { toArray } from '../array/toArray.js';
+import { toObject } from '../object/toObject.js';
+import { toInteger } from '../integer/toInteger.js';
+import { toNumber } from '../number/toNumber.js';
+import { toBoolean } from '../boolean/toBoolean.js';
+import { toString } from '../string/toString.js';
+import { toUnknown } from '../unknown/toUnknown.js';
+import { toUnion } from '../union/toUnion.js';
+import { toGetRef } from '../../../helpers/refFns.js';
+import { mergeIntersection } from '../_merge-all-of/merge-intersection.js';
+import { mergeUnion } from '../_merge-all-of/merge-union.js';
+import { tryParseAt } from '../../../context/tryParseAt.js';
+export const toSchemasV3 = ({ schemas, stackTrail, context }) => {
+    const output = {};
+    const entries = Object.entries(schemas);
+    for (const [key, schema] of entries) {
+        const value = tryParseAt({
+            stackTrail,
+            key,
+            context,
+            type: 'INVALID_SCHEMA',
+            parent: schema,
+            fn: st => toSchemaV3({ schema, stackTrail: st, context })
+        });
+        if (value !== undefined) {
+            output[key] = value;
+        }
+    }
+    return output;
+};
+export const toOptionalSchemasV3 = ({ schemas, stackTrail, context }) => {
+    if (!schemas) {
+        return undefined;
+    }
+    return toSchemasV3({ schemas, stackTrail, context });
+};
+/**
+ * OpenAPI 3.1 lets a schema's `type` be an ARRAY (e.g. `['string', 'null']`),
+ * which the shared IR — modelling a single `type` plus a `nullable` flag —
+ * does not. Normalize the array form into shapes the rest of the dispatcher
+ * already understands:
+ *
+ *   - `['T', 'null']`   (one non-null type)  → `{ type: 'T', nullable: true }`
+ *   - `['T1', 'T2', …]` (several non-null)   → a `oneOf` of the bare types,
+ *     i.e. the 3.1 multi-type union. 3.0 cannot express this — it is the
+ *     CASE-2 gap where the v3-0 parser degrades to OasUnknown.
+ *   - `['null']`        (only null)          → left unchanged → OasUnknown,
+ *     since there is no first-class OasNull IR node yet (a documented gap).
+ *
+ * The hoisted `nullable` flag is the IR's representation of nullability; the
+ * leaf parsers read it via `parseNullable`. A non-array `type` passes through.
+ */
+const normalizeTypeArray = (schema) => {
+    const rawType = schema.type;
+    if (!Array.isArray(rawType)) {
+        return schema;
+    }
+    const members = rawType.filter(member => member !== 'null');
+    const nullable = rawType.length !== members.length || schema.nullable;
+    // Only `null` (`type: ['null']`): no OasNull node yet — fall through.
+    if (members.length === 0) {
+        return schema;
+    }
+    // Several non-null types: a 3.1 multi-type union. Model it as a `oneOf`
+    // of the bare types and let the oneOf branch build the OasUnion.
+    if (members.length > 1) {
+        const { type: _type, ...rest } = schema;
+        return { ...rest, nullable, oneOf: members.map(member => ({ type: member })) };
+    }
+    // Exactly one non-null type: dispatch as that type, carrying nullability.
+    switch (members[0]) {
+        case 'object':
+        case 'integer':
+        case 'number':
+        case 'boolean':
+        case 'string':
+            return { ...schema, type: members[0], nullable };
+        case 'array':
+            return 'items' in schema ? { ...schema, type: members[0], nullable } : schema;
+        default:
+            return schema;
+    }
+};
+/**
+ * OpenAPI 3.1 `const: X` is the single-value form of `enum` (3.0 expresses a
+ * literal as a one-element `enum`). Rewrite it so the existing enum-aware leaf
+ * parsers handle it; matches down-convert's `convertConstToEnum`, so a 3.0
+ * `enum:[X]` and a 3.1 `const:X` land on the same IR.
+ */
+const normalizeConst = (schema) => {
+    if (!('const' in schema)) {
+        return schema;
+    }
+    // `const` is a 3.1 keyword the 3.0-typed SchemaObject does not model; read
+    // it via an annotated destructure rather than a cast.
+    const { const: constValue, ...rest } = schema;
+    return { ...rest, enum: [constValue] };
+};
+/**
+ * OpenAPI 3.1 schemas carry `examples` (an array, JSON Schema 2020-12); 3.0
+ * and the IR use a single `example`. Adopt the first array element as the IR
+ * `example` when no singular `example` is set, and drop the array. Matches
+ * down-convert's `convertJsonSchemaExamples`.
+ */
+const normalizeExamples = (schema) => {
+    if ('example' in schema || !('examples' in schema)) {
+        return schema;
+    }
+    // `examples` is a 3.1 keyword the 3.0-typed SchemaObject does not model.
+    const { examples, ...rest } = schema;
+    if (!Array.isArray(examples) || examples.length === 0) {
+        return rest;
+    }
+    return { ...rest, example: examples[0] };
+};
+/**
+ * OpenAPI 3.1 expresses exclusive bounds as NUMBERS (`exclusiveMinimum: 5`
+ * means "> 5"); the shared IR (and 3.0) model them as a boolean flag paired
+ * with `minimum`/`maximum`. Convert the numeric form so the number/integer
+ * leaves validate. Matches down-convert's `convertExclusiveMinMax`, so a 3.0
+ * `{minimum:5, exclusiveMinimum:true}` and a 3.1 `{exclusiveMinimum:5}` land
+ * on the same IR.
+ */
+const normalizeExclusiveBounds = (schema) => {
+    // `exclusiveMinimum`/`exclusiveMaximum` are 3.0-typed boolean here; in 3.1
+    // they arrive as numbers, so read them loosely.
+    const exclusiveMinimum = schema.exclusiveMinimum;
+    const exclusiveMaximum = schema.exclusiveMaximum;
+    if (typeof exclusiveMinimum !== 'number' && typeof exclusiveMaximum !== 'number') {
+        return schema;
+    }
+    const next = { ...schema };
+    if (typeof exclusiveMinimum === 'number') {
+        next.minimum = exclusiveMinimum;
+        next.exclusiveMinimum = true;
+    }
+    if (typeof exclusiveMaximum === 'number') {
+        next.maximum = exclusiveMaximum;
+        next.exclusiveMaximum = true;
+    }
+    return next;
+};
+/**
+ * OpenAPI 3.1 / JSON Schema 2020-12 expresses a binary string payload with
+ * `contentMediaType: 'application/octet-stream'` and base64 with
+ * `contentEncoding: 'base64'`; the shared IR (and 3.0) carry these as a string
+ * `format` (`binary` / `byte`, both in the format allow-list). Map them so the
+ * format reaches the IR. Mirrors down-convert's
+ * `convertJsonSchemaContentMediaType` / `convertJsonSchemaContentEncoding`:
+ * string schemas only, and a pre-existing (conflicting) `format` wins — the
+ * content keyword is dropped, not overwritten. Without this, retiring
+ * down-convert would silently lose the `format` signal on 3.1 binary uploads.
+ */
+const normalizeContentFormat = (schema) => {
+    if (schema.type !== 'string') {
+        return schema;
+    }
+    // `contentMediaType`/`contentEncoding` are 3.1 keywords the 3.0-typed
+    // SchemaObject does not model; read them loosely.
+    const view = schema;
+    const derivedFormat = view.contentMediaType === 'application/octet-stream'
+        ? 'binary'
+        : view.contentEncoding === 'base64'
+            ? 'byte'
+            : undefined;
+    if (derivedFormat === undefined) {
+        return schema;
+    }
+    const { contentMediaType: _contentMediaType, contentEncoding: _contentEncoding, ...rest } = view;
+    return 'format' in rest ? rest : { ...rest, format: derivedFormat };
+};
+/**
+ * Map the 3.1-only schema-shape encodings onto the shared IR shape before
+ * dispatching: type arrays, `const`, `examples[]`, numeric exclusive bounds,
+ * and binary/base64 content keywords. Each step returns its input unchanged
+ * when it does not apply, so the composed result is referentially equal to
+ * `schema` when nothing matched — letting the dispatcher re-dispatch only when
+ * needed.
+ */
+const normalizeSchemaShape = (schema) => {
+    return normalizeExclusiveBounds(normalizeExamples(normalizeConst(normalizeContentFormat(normalizeTypeArray(schema)))));
+};
+/**
+ * Is this a 3.1 `{ type: 'null' }` schema member? (`'null'` is a 3.1 type
+ * literal the 3.0-typed SchemaObject does not model, so read it loosely.)
+ */
+const isNullTypeSchema = (member) => {
+    if (isRef(member)) {
+        return false;
+    }
+    const type = member.type;
+    return type === 'null';
+};
+/**
+ * Split `oneOf`/`anyOf` members into the non-null members plus whether a
+ * `{ type: 'null' }` member was present. In 3.1 that null member is how a
+ * union expresses nullability (3.0 used the hoisted `nullable` keyword);
+ * folding it into a flag lets the collapse/union logic stay unchanged.
+ */
+const partitionNullMember = (members) => {
+    const nonNull = members.filter(member => !isNullTypeSchema(member));
+    return { members: nonNull, nullable: nonNull.length !== members.length };
+};
+/**
+ * Collapse a single-member `oneOf`/`anyOf` into its surviving member.
+ *
+ * The wrapper's sibling keywords must ride into the member rather than
+ * being discarded. The critical one is `nullable`: the 3.1 idiom
+ * `oneOf:[{type:'string'},{type:'null'}]` ("string or null") has its
+ * `{type:'null'}` member folded out by `partitionNullMember` above, leaving
+ * `oneOf:[{type:'string'}]` + `nullable:true` on the wrapper. Re-dispatching
+ * `members[0]` alone would drop the wrapper (`...value`) and silently turn
+ * `string | null` back into a non-nullable `string`.
+ * `description`/`title`/`readOnly`/... ride along the same way.
+ *
+ * Precedence: the member is the more specific schema, so it wins direct
+ * conflicts (`{ ...value, ...member }`). `nullable` is the exception — it
+ * OR-ins, because a nullable wrapper makes the whole schema nullable even
+ * when the member itself is not.
+ *
+ * A ref member only reaches here when the wrapper carries no `nullable`
+ * (the nullable-ref case stamps `nullable` on the OasRef node at the call
+ * site, via `toRefV31`). Any other wrapper siblings on a bare `$ref` are
+ * ignored per 3.0 ref semantics, so the ref is returned untouched.
+ */
+const collapseSingleMember = (value, member) => {
+    if (isRef(member)) {
+        return member;
+    }
+    const merged = { ...value, ...member };
+    if (value.nullable || member.nullable) {
+        merged.nullable = true;
+    }
+    return merged;
+};
+export const toSchemaV3 = ({ schema, stackTrail, context }) => {
+    if (isRef(schema)) {
+        return toRefV31({ ref: schema, refType: 'schema', stackTrail, context });
+    }
+    // OpenAPI `not` has no faithful TypeScript representation: a generated type
+    // that ignored it would *widen* the contract (accepting shapes the schema
+    // forbids). Refuse the schema rather than emit a type that lies. The throw
+    // is isolated by `tryParseAt` into an `INVALID_SCHEMA` issue, and consumers
+    // of this schema are pruned via `removeErroredItems` (INVALID_DEPENDENCY_REF).
+    if ('not' in schema) {
+        throw new Error('Schema uses unsupported "not" keyword');
+    }
+    const normalized = normalizeSchemaShape(schema);
+    if (normalized !== schema) {
+        return toSchemaV3({ schema: normalized, stackTrail, context });
+    }
+    if ('allOf' in schema && Array.isArray(schema.allOf)) {
+        return stackTrail.trace('allOf', st => {
+            // A single-member allOf collapses to its sole member — the value must
+            // satisfy exactly that one schema. When the member is a `$ref`, keep it
+            // LAZY (as an OasRef) rather than resolving + merging its target: a
+            // `{ allOf: [{$ref: self}], nullable: true }` (a nullable reference
+            // written as a one-member allOf — common in real specs) is
+            // self-referential, and eagerly resolving it would not terminate. The
+            // ref resolves at use time like every other ref. Mirrors the
+            // single-member oneOf/anyOf handling below.
+            const { allOf, ...value } = schema;
+            const members = allOf ?? [];
+            if (members.length === 1) {
+                const [member] = members;
+                if (isRef(member) && value.nullable) {
+                    return toRefV31({
+                        ref: member,
+                        refType: 'schema',
+                        nullable: true,
+                        stackTrail: st,
+                        context
+                    });
+                }
+                return toSchemaV3({
+                    schema: collapseSingleMember(value, member),
+                    stackTrail: st,
+                    context
+                });
+            }
+            const merged = mergeIntersection({
+                schema,
+                getRef: toGetRef(context.documentObject)
+            });
+            return toSchemaV3({ schema: merged, stackTrail: st, context });
+        });
+    }
+    if ('oneOf' in schema && Array.isArray(schema.oneOf)) {
+        return stackTrail.trace('oneOf', st => {
+            // 3.1: a `{ type: 'null' }` member makes the union nullable. Fold it
+            // into a `nullable` flag the collapse/union logic already understands.
+            const { members: oneOfWithoutNull, nullable: hasNullMember } = partitionNullMember(schema.oneOf ?? []);
+            const withoutNull = hasNullMember
+                ? { ...schema, oneOf: oneOfWithoutNull, nullable: true }
+                : schema;
+            const merged = mergeUnion({
+                schema: withoutNull,
+                getRef: toGetRef(context.documentObject),
+                groupType: 'oneOf'
+            });
+            if (!('oneOf' in merged) || !Array.isArray(merged.oneOf)) {
+                throw new Error('Missing "oneOf" array');
+            }
+            const { oneOf: members, ...value } = merged;
+            if (members.length === 0) {
+                throw new Error('"oneOf" array is empty');
+            }
+            if (members.length === 1) {
+                const [soleMember] = members;
+                // A 3.1 nullable reference `oneOf:[{$ref},{type:'null'}]` becomes a
+                // single `$ref` member + `nullable:true` once the null member above
+                // is folded out. Nullability here is a *use-site* property — the same
+                // refName may be referenced nullable at one site and not another — so
+                // it rides the OasRef node itself, NOT the shared referent and NOT a
+                // synthetic union. Generators read `ref.nullable` and render
+                // `Foo | null`; `ModelDriver` builds the un-nullable shared `Foo` from
+                // the refName. See
+                // notes/openapi-3.1-webhooks-and-parser-architecture.md §3.4.
+                if (isRef(soleMember) && value.nullable) {
+                    return toRefV31({
+                        ref: soleMember,
+                        refType: 'schema',
+                        nullable: true,
+                        stackTrail: st,
+                        context
+                    });
+                }
+                return toSchemaV3({
+                    schema: collapseSingleMember(value, soleMember),
+                    stackTrail: st,
+                    context
+                });
+            }
+            return toUnion({ value, members, parentType: 'oneOf', stackTrail: st, context });
+        });
+    }
+    if ('anyOf' in schema && Array.isArray(schema.anyOf)) {
+        return stackTrail.trace('anyOf', st => {
+            // deno-lint-ignore ban-ts-comment
+            // @ts-expect-error
+            if (schema['x-expansionResources'] && Array.isArray(schema.anyOf)) {
+                const { anyOf, ...value } = schema;
+                return toUnion({ value, members: anyOf, parentType: 'anyOf', stackTrail: st, context });
+            }
+            // 3.1: a `{ type: 'null' }` member makes the union nullable (mirrors
+            // the oneOf branch above).
+            const { members: anyOfWithoutNull, nullable: hasNullMember } = partitionNullMember(schema.anyOf ?? []);
+            const withoutNull = hasNullMember
+                ? { ...schema, anyOf: anyOfWithoutNull, nullable: true }
+                : schema;
+            const merged = mergeUnion({
+                schema: withoutNull,
+                getRef: toGetRef(context.documentObject),
+                groupType: 'anyOf'
+            });
+            if (!('anyOf' in merged) || !Array.isArray(merged.anyOf)) {
+                throw new Error('Missing "anyOf" array');
+            }
+            const { anyOf: members, ...value } = merged;
+            if (members.length === 0) {
+                throw new Error('"anyOf" array is empty');
+            }
+            if (members.length === 1) {
+                const [soleMember] = members;
+                // See the oneOf branch: a single `$ref` carrying a hoisted `nullable`
+                // sets `nullable` on the OasRef node itself.
+                if (isRef(soleMember) && value.nullable) {
+                    return toRefV31({
+                        ref: soleMember,
+                        refType: 'schema',
+                        nullable: true,
+                        stackTrail: st,
+                        context
+                    });
+                }
+                return toSchemaV3({
+                    schema: collapseSingleMember(value, soleMember),
+                    stackTrail: st,
+                    context
+                });
+            }
+            return toUnion({ value, members, parentType: 'anyOf', stackTrail: st, context });
+        });
+    }
+    if ('type' in schema) {
+        switch (schema.type) {
+            case 'object':
+                return toObject({ value: schema, stackTrail, context });
+            case 'array':
+                return toArray({ value: schema, stackTrail, context });
+            case 'integer':
+                return toInteger({ value: schema, stackTrail, context });
+            case 'number':
+                return toNumber({ value: schema, stackTrail, context });
+            case 'boolean':
+                return toBoolean({ value: schema, stackTrail, context });
+            case 'string':
+                return toString({ value: schema, stackTrail, context });
+        }
+    }
+    // Otherwise cases
+    if (possibleObject(schema)) {
+        // In 3.1 `type` is optional, so a schema with `properties` and no `type`
+        // is a normal, valid object schema — inferring `object` is the expected
+        // reading, not a deviation, so it is silent. (The v3-0 parser keeps the
+        // MISSING_OBJECT_TYPE warning: 3.0 requires `type`, so its absence there
+        // is a real signal.)
+        return toObject({
+            value: {
+                ...schema,
+                type: 'object'
+            },
+            stackTrail,
+            context
+        });
+    }
+    if (possibleArray(schema)) {
+        context.logIssueNoKey({
+            level: 'warning',
+            message: 'Object has "items" property, but is missing type="array" property',
+            parent: schema,
+            stackTrail,
+            type: 'MISSING_ARRAY_TYPE'
+        });
+        return toArray({
+            value: {
+                ...schema,
+                type: 'array'
+                // Adding cast here since {} is a valid value for items
+            },
+            stackTrail,
+            context
+        });
+    }
+    if (possibleBoolean(schema)) {
+        context.logIssueNoKey({
+            level: 'warning',
+            message: 'Object has a boolean "default" or "example" property, but is missing type="boolean" property',
+            parent: schema,
+            stackTrail,
+            type: 'MISSING_BOOLEAN_TYPE'
+        });
+        return toBoolean({
+            value: {
+                ...schema,
+                type: 'boolean'
+            },
+            stackTrail,
+            context
+        });
+    }
+    if (possibleString(schema)) {
+        context.logIssueNoKey({
+            level: 'warning',
+            message: 'Object has a string "default" or "example" property, but is missing type="string" property',
+            parent: schema,
+            stackTrail,
+            type: 'MISSING_STRING_TYPE'
+        });
+        return toString({
+            value: {
+                ...schema,
+                type: 'string'
+            },
+            stackTrail,
+            context
+        });
+    }
+    return toUnknown({ value: schema, stackTrail, context });
+};
+const possibleString = (value) => {
+    return (value &&
+        typeof value === 'object' &&
+        (('default' in value && typeof value.default === 'string') ||
+            ('example' in value && typeof value.example === 'string') ||
+            ('enum' in value &&
+                Array.isArray(value.enum) &&
+                value.enum.every(item => typeof item === 'string')) ||
+            ('format' in value &&
+                typeof value.format === 'string' &&
+                ['date', 'date-time', 'binary', 'byte'].includes(value.format))));
+};
+const possibleBoolean = (value) => {
+    return (value &&
+        typeof value === 'object' &&
+        (('default' in value && typeof value.default === 'boolean') ||
+            ('example' in value && typeof value.example === 'boolean')));
+};
+const possibleArray = (value) => {
+    return (value &&
+        typeof value === 'object' &&
+        'items' in value &&
+        value.items &&
+        typeof value.items === 'object' &&
+        value.items);
+};
+const possibleObject = (value) => {
+    return (value &&
+        typeof value === 'object' &&
+        'properties' in value &&
+        typeof value.properties === 'object' &&
+        value.properties);
+};
+export const toOptionalSchemaV3 = ({ schema, stackTrail, context }) => {
+    if (!schema) {
+        return undefined;
+    }
+    return toSchemaV3({ schema, stackTrail, context });
+};

package/esm/parse/v3-2/securityRequirement/toSecurityRequirement.d.ts

@@ -0,0 +1,9 @@
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasSecurityRequirement } from '../../../oas/securityRequirement/SecurityRequirement.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToSecurityRequirementsV3Args = {
+    security: Record<string, string[]>[] | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toSecurityRequirementsV3: ({ security, stackTrail, context }: ToSecurityRequirementsV3Args) => OasSecurityRequirement[] | undefined;

package/esm/parse/v3-2/securityRequirement/toSecurityRequirement.js

@@ -0,0 +1,9 @@
+import { OasSecurityRequirement } from '../../../oas/securityRequirement/SecurityRequirement.js';
+export const toSecurityRequirementsV3 = ({ security, stackTrail, context }) => {
+    if (!security) {
+        return undefined;
+    }
+    return security.map(requirement => {
+        return new OasSecurityRequirement({ requirement }, context.oasDocument);
+    });
+};

package/esm/parse/v3-2/securitySchemes/toSecuritySchemes.d.ts

@@ -0,0 +1,17 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { OasSecurityScheme } from '../../../oas/securitySchemes/SecurityScheme.js';
+import type { OasRef } from '../../../oas/ref/Ref.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToSecuritySchemesArgs = {
+    securitySchemes: Record<string, OpenAPIV3.ReferenceObject | OpenAPIV3.SecuritySchemeObject> | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toSecuritySchemesV3: ({ securitySchemes, stackTrail, context }: ToSecuritySchemesArgs) => // 'http' | 'apiKey' | 'oauth2' | 'openIdConnect'
+Record<string, OasSecurityScheme | OasRef<"securityScheme">> | undefined;
+export type ToSecuritySchemeV3Args = {
+    securityScheme: OpenAPIV3.ReferenceObject | OpenAPIV3.SecuritySchemeObject;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};