@skmtc/core 0.0.983 → 0.16.1

package/esm/parse/v3-0/string/toString.d.ts

@@ -0,0 +1,147 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasString } from '../../../oas/string/String.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+/**
+ * Arguments for transforming an OpenAPI string schema into OAS representation.
+ */
+export type ToStringArgs = {
+    /** The OpenAPI v3 schema object to transform (must be type 'string') */
+    value: OpenAPIV3.SchemaObject;
+    /** The stack trail for tracing */
+    stackTrail: StackTrail;
+    /** Parse context providing utilities and tracing capabilities */
+    context: ParseContextType;
+};
+/**
+ * Transforms an OpenAPI v3 string schema object into an internal OAS string representation.
+ *
+ * This function processes OpenAPI string schemas by extracting and parsing nullable values,
+ * examples, enumerations, and default values. It handles the complete transformation from
+ * raw OpenAPI JSON to the SKMTC internal string representation with proper validation
+ * of string formats and constraints.
+ *
+ * The transformation follows a pipeline approach:
+ * 1. Parse nullable flag and extract base value
+ * 2. Parse example values with nullable support
+ * 3. Parse enumeration constraints
+ * 4. Parse default values
+ * 5. Create final OasString instance with format validation
+ *
+ * @param args - Transformation arguments
+ * @param args.context - Parse context providing utilities and tracing
+ * @param args.value - The OpenAPI v3 string schema object to transform
+ * @returns Transformed OAS string object with parsed properties
+ *
+ * @example Basic string transformation
+ * ```typescript
+ * import { toString } from '@skmtc/core';
+ *
+ * const openApiString = {
+ *   type: 'string',
+ *   format: 'email',
+ *   maxLength: 255,
+ *   pattern: '^[\\w.-]+@[\\w.-]+\\.[a-zA-Z]{2,}$'
+ * };
+ *
+ * const oasString = toString({
+ *   context: parseContext,
+ *   value: openApiString
+ * });
+ *
+ * console.log(oasString.format); // 'email'
+ * console.log(oasString.maxLength); // 255
+ * ```
+ *
+ * @example String with nullable and enums
+ * ```typescript
+ * const statusString = {
+ *   type: 'string',
+ *   nullable: true,
+ *   enum: ['active', 'inactive', 'pending', null],
+ *   default: 'active',
+ *   example: 'pending'
+ * };
+ *
+ * const oasString = toString({
+ *   context: parseContext,
+ *   value: statusString
+ * });
+ *
+ * console.log(oasString.nullable); // true
+ * console.log(oasString.enums); // ['active', 'inactive', 'pending', null]
+ * ```
+ */
+export declare const toString: ({ context, value, stackTrail }: ToStringArgs) => OasString;
+type ToParsedStringArgs<Nullable extends boolean | undefined> = {
+    value: Omit<OpenAPIV3.SchemaObject, 'nullable' | 'example' | 'enums' | 'default'>;
+    context: ParseContextType;
+    nullable: Nullable;
+    example: Nullable extends true ? string | null | undefined : string | undefined;
+    enums: Nullable extends true ? (string | null)[] | undefined : string[] | undefined;
+    defaultValue: Nullable extends true ? string | null | undefined : string | undefined;
+    stackTrail: StackTrail;
+};
+/**
+ * Creates an OAS string instance from pre-parsed string schema components.
+ *
+ * This function is the final step in the string transformation pipeline, taking
+ * already-parsed nullable, example, enum, and default values and combining them
+ * with the remaining string properties to create the complete OasString instance.
+ *
+ * The function handles format validation against known OpenAPI string formats,
+ * length constraints parsing, pattern validation, and specification extension
+ * processing. It logs warnings for unrecognized formats while still preserving
+ * them in the output.
+ *
+ * @template Nullable - Boolean type indicating if the string can be null
+ * @param args - Pre-parsed string components
+ * @param args.context - Parse context for tracing and issue logging
+ * @param args.nullable - Parsed nullable flag
+ * @param args.example - Parsed example value (type-safe with nullable)
+ * @param args.enums - Parsed enumeration constraints (type-safe with nullable)
+ * @param args.defaultValue - Parsed default value (type-safe with nullable)
+ * @param args.value - OpenAPI string object without parsed fields
+ * @returns Complete OAS string instance with all properties and validation
+ *
+ * @example Date-time string with validation
+ * ```typescript
+ * const dateTimeString = toParsedString({
+ *   context: parseContext,
+ *   nullable: false,
+ *   example: '2023-12-25T10:00:00Z',
+ *   enums: undefined,
+ *   defaultValue: undefined,
+ *   value: {
+ *     type: 'string',
+ *     format: 'date-time',
+ *     title: 'Event Date',
+ *     description: 'When the event occurs'
+ *   }
+ * });
+ *
+ * console.log(dateTimeString.format); // 'date-time'
+ * ```
+ *
+ * @example String with custom format (generates warning)
+ * ```typescript
+ * const customFormatString = toParsedString({
+ *   context: parseContext,
+ *   nullable: false,
+ *   example: 'ABC123',
+ *   enums: undefined,
+ *   defaultValue: undefined,
+ *   value: {
+ *     type: 'string',
+ *     format: 'custom-id', // Unknown format, will log warning
+ *     pattern: '^[A-Z]{3}[0-9]{3}$'
+ *   }
+ * });
+ *
+ * // Logs: "Unexpected format: custom-id"
+ * console.log(customFormatString.format); // 'custom-id' (still preserved)
+ * ```
+ */
+export declare const toParsedString: <Nullable extends boolean | undefined>({ context, nullable, example, enums, defaultValue, value, stackTrail }: ToParsedStringArgs<Nullable>) => OasString<Nullable>;
+export {};
+//# sourceMappingURL=toString.d.ts.map

package/esm/parse/v3-0/string/toString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toString.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-0/string/toString.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAA;AAQzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAEhE;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,wEAAwE;IACxE,KAAK,EAAE,SAAS,CAAC,YAAY,CAAA;IAC7B,kCAAkC;IAClC,UAAU,EAAE,UAAU,CAAA;IACtB,iEAAiE;IACjE,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,eAAO,MAAM,QAAQ,GAAI,gCAAgC,YAAY,KAAG,SAwDvE,CAAA;AAED,KAAK,kBAAkB,CAAC,QAAQ,SAAS,OAAO,GAAG,SAAS,IAAI;IAC9D,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,UAAU,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC,CAAA;IACjF,OAAO,EAAE,gBAAgB,CAAA;IACzB,QAAQ,EAAE,QAAQ,CAAA;IAClB,OAAO,EAAE,QAAQ,SAAS,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAAA;IAC/E,KAAK,EAAE,QAAQ,SAAS,IAAI,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,GAAG,SAAS,GAAG,MAAM,EAAE,GAAG,SAAS,CAAA;IACnF,YAAY,EAAE,QAAQ,SAAS,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAAA;IACpF,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,eAAO,MAAM,cAAc,GAAI,QAAQ,SAAS,OAAO,GAAG,SAAS,EAAE,wEAQlE,kBAAkB,CAAC,QAAQ,CAAC,KAAG,SAAS,CAAC,QAAQ,CA2DnD,CAAA"}

package/esm/parse/v3-0/string/toString.js

@@ -0,0 +1,218 @@
+import { OasString } from '../../../oas/string/String.js';
+import { toSpecificationExtensionsV3 } from '../specificationExtensions/toSpecificationExtensionsV3.js';
+import { oasStringData, stringFormat } from '../../../oas/string/string-types.js';
+import * as v from 'valibot';
+import { parseNullable } from '../_helpers/parseNullable.js';
+import { parseEnum } from '../_helpers/parseEnum.js';
+import { parseExample } from '../_helpers/parseExample.js';
+import { parseDefault } from '../_helpers/parseDefault.js';
+/**
+ * Transforms an OpenAPI v3 string schema object into an internal OAS string representation.
+ *
+ * This function processes OpenAPI string schemas by extracting and parsing nullable values,
+ * examples, enumerations, and default values. It handles the complete transformation from
+ * raw OpenAPI JSON to the SKMTC internal string representation with proper validation
+ * of string formats and constraints.
+ *
+ * The transformation follows a pipeline approach:
+ * 1. Parse nullable flag and extract base value
+ * 2. Parse example values with nullable support
+ * 3. Parse enumeration constraints
+ * 4. Parse default values
+ * 5. Create final OasString instance with format validation
+ *
+ * @param args - Transformation arguments
+ * @param args.context - Parse context providing utilities and tracing
+ * @param args.value - The OpenAPI v3 string schema object to transform
+ * @returns Transformed OAS string object with parsed properties
+ *
+ * @example Basic string transformation
+ * ```typescript
+ * import { toString } from '@skmtc/core';
+ *
+ * const openApiString = {
+ *   type: 'string',
+ *   format: 'email',
+ *   maxLength: 255,
+ *   pattern: '^[\\w.-]+@[\\w.-]+\\.[a-zA-Z]{2,}$'
+ * };
+ *
+ * const oasString = toString({
+ *   context: parseContext,
+ *   value: openApiString
+ * });
+ *
+ * console.log(oasString.format); // 'email'
+ * console.log(oasString.maxLength); // 255
+ * ```
+ *
+ * @example String with nullable and enums
+ * ```typescript
+ * const statusString = {
+ *   type: 'string',
+ *   nullable: true,
+ *   enum: ['active', 'inactive', 'pending', null],
+ *   default: 'active',
+ *   example: 'pending'
+ * };
+ *
+ * const oasString = toString({
+ *   context: parseContext,
+ *   value: statusString
+ * });
+ *
+ * console.log(oasString.nullable); // true
+ * console.log(oasString.enums); // ['active', 'inactive', 'pending', null]
+ * ```
+ */
+export const toString = ({ context, value, stackTrail }) => {
+    if (value.type === 'string' && Object.keys(value).length === 1) {
+        return context.withStackTrail(stackTrail, () => new OasString({}, context));
+    }
+    const { nullable, value: valueWithoutNullable } = parseNullable({
+        value,
+        context,
+        stackTrail
+    });
+    const { example: unparsedExample, ...valueWithoutExample } = valueWithoutNullable;
+    const example = parseExample({
+        value: unparsedExample,
+        context,
+        parent: valueWithoutNullable,
+        nullable,
+        check: isString,
+        toMessage: item => `Removed invalid example. Expected "string", got: ${item}`,
+        stackTrail
+    });
+    const { enum: unparsedEnums, ...valueWithoutEnums } = valueWithoutExample;
+    const enums = parseEnum({
+        value: unparsedEnums,
+        nullable,
+        parent: valueWithoutExample,
+        context,
+        check: isString,
+        toMessage: item => `Removed invalid enum. Expected "string", got: ${item}`,
+        stackTrail
+    });
+    const { default: unparsedDefaultValue, ...valueWithoutDefault } = valueWithoutEnums;
+    const defaultValue = parseDefault({
+        value: unparsedDefaultValue,
+        context,
+        parent: valueWithoutEnums,
+        nullable,
+        check: isString,
+        toMessage: item => `Removed invalid default. Expected "string", got: ${item}`,
+        stackTrail
+    });
+    return toParsedString({
+        context,
+        nullable,
+        example,
+        enums,
+        defaultValue,
+        value: valueWithoutDefault,
+        stackTrail
+    });
+};
+/**
+ * Creates an OAS string instance from pre-parsed string schema components.
+ *
+ * This function is the final step in the string transformation pipeline, taking
+ * already-parsed nullable, example, enum, and default values and combining them
+ * with the remaining string properties to create the complete OasString instance.
+ *
+ * The function handles format validation against known OpenAPI string formats,
+ * length constraints parsing, pattern validation, and specification extension
+ * processing. It logs warnings for unrecognized formats while still preserving
+ * them in the output.
+ *
+ * @template Nullable - Boolean type indicating if the string can be null
+ * @param args - Pre-parsed string components
+ * @param args.context - Parse context for tracing and issue logging
+ * @param args.nullable - Parsed nullable flag
+ * @param args.example - Parsed example value (type-safe with nullable)
+ * @param args.enums - Parsed enumeration constraints (type-safe with nullable)
+ * @param args.defaultValue - Parsed default value (type-safe with nullable)
+ * @param args.value - OpenAPI string object without parsed fields
+ * @returns Complete OAS string instance with all properties and validation
+ *
+ * @example Date-time string with validation
+ * ```typescript
+ * const dateTimeString = toParsedString({
+ *   context: parseContext,
+ *   nullable: false,
+ *   example: '2023-12-25T10:00:00Z',
+ *   enums: undefined,
+ *   defaultValue: undefined,
+ *   value: {
+ *     type: 'string',
+ *     format: 'date-time',
+ *     title: 'Event Date',
+ *     description: 'When the event occurs'
+ *   }
+ * });
+ *
+ * console.log(dateTimeString.format); // 'date-time'
+ * ```
+ *
+ * @example String with custom format (generates warning)
+ * ```typescript
+ * const customFormatString = toParsedString({
+ *   context: parseContext,
+ *   nullable: false,
+ *   example: 'ABC123',
+ *   enums: undefined,
+ *   defaultValue: undefined,
+ *   value: {
+ *     type: 'string',
+ *     format: 'custom-id', // Unknown format, will log warning
+ *     pattern: '^[A-Z]{3}[0-9]{3}$'
+ *   }
+ * });
+ *
+ * // Logs: "Unexpected format: custom-id"
+ * console.log(customFormatString.format); // 'custom-id' (still preserved)
+ * ```
+ */
+export const toParsedString = ({ context, nullable, example, enums, defaultValue, value, stackTrail }) => {
+    if (!v.is(oasStringData, value)) {
+        v.parse(oasStringData, value);
+    }
+    const { type: _type, title, description, format, maxLength, minLength, pattern, readOnly, writeOnly, deprecated, ...skipped } = value;
+    const extensionFields = toSpecificationExtensionsV3({
+        skipped,
+        parent: value,
+        context,
+        stackTrail,
+        parentType: 'schema:string'
+    });
+    if (format && !v.is(stringFormat, format)) {
+        context.logIssue({
+            key: 'format',
+            level: 'warning',
+            message: `Unexpected format: ${format}`,
+            parent: value,
+            stackTrail,
+            type: 'UNEXPECTED_FORMAT'
+        });
+    }
+    return context.withStackTrail(stackTrail, () => new OasString({
+        title,
+        description,
+        enums,
+        nullable,
+        example,
+        format,
+        maxLength,
+        minLength,
+        pattern,
+        readOnly,
+        writeOnly,
+        default: defaultValue,
+        extensionFields,
+        deprecated
+    }, context));
+};
+const isString = (value) => {
+    return typeof value === 'string';
+};

package/esm/parse/v3-0/tag/toTagsV3.d.ts

@@ -0,0 +1,17 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasTag } from '../../../oas/tag/Tag.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToTagsV3Args = {
+    tags: OpenAPIV3.TagObject[] | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toTagsV3: ({ tags, stackTrail, context }: ToTagsV3Args) => OasTag[] | undefined;
+export type ToTagV3Args = {
+    tag: OpenAPIV3.TagObject;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toTagV3: ({ tag, stackTrail, context }: ToTagV3Args) => OasTag;
+//# sourceMappingURL=toTagsV3.d.ts.map

package/esm/parse/v3-0/tag/toTagsV3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toTagsV3.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-0/tag/toTagsV3.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAIhD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAEhE,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,SAAS,CAAC,SAAS,EAAE,GAAG,SAAS,CAAA;IACvC,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,QAAQ,GAAI,+BAA+B,YAAY,KAAG,MAAM,EAAE,GAAG,SAMjF,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,GAAG,EAAE,SAAS,CAAC,SAAS,CAAA;IACxB,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,OAAO,GAAI,8BAA8B,WAAW,KAAG,MAuBnE,CAAA"}

package/esm/parse/v3-0/tag/toTagsV3.js

@@ -0,0 +1,27 @@
+import { OasTag } from '../../../oas/tag/Tag.js';
+import { toSpecificationExtensionsV3 } from '../specificationExtensions/toSpecificationExtensionsV3.js';
+import { toExternalDocs } from '../externalDocs/toExternalDocs.js';
+export const toTagsV3 = ({ tags, stackTrail, context }) => {
+    if (!tags) {
+        return undefined;
+    }
+    return tags.map(tag => toTagV3({ tag, stackTrail, context }));
+};
+export const toTagV3 = ({ tag, stackTrail, context }) => {
+    const { name, description, externalDocs, ...skipped } = tag;
+    const parsedExternalDocs = stackTrail.trace('externalDocs', st => toExternalDocs({ externalDocs, stackTrail: st, context }));
+    const extensionFields = toSpecificationExtensionsV3({
+        skipped,
+        parent: tag,
+        context,
+        stackTrail,
+        parentType: 'tag'
+    });
+    const fields = {
+        name,
+        description,
+        externalDocs: parsedExternalDocs,
+        extensionFields
+    };
+    return new OasTag(fields);
+};

package/esm/parse/v3-0/union/toUnion.d.ts

@@ -0,0 +1,13 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasUnion } from '../../../oas/union/Union.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToUnionArgs = {
+    value: OpenAPIV3.SchemaObject;
+    members: (OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject)[];
+    parentType: 'anyOf' | 'oneOf';
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toUnion: ({ value, members, parentType, stackTrail, context }: ToUnionArgs) => OasUnion;
+//# sourceMappingURL=toUnion.d.ts.map

package/esm/parse/v3-0/union/toUnion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toUnion.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-0/union/toUnion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAA;AAStD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAChE,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,SAAS,CAAC,YAAY,CAAA;IAC7B,OAAO,EAAE,CAAC,SAAS,CAAC,eAAe,GAAG,SAAS,CAAC,YAAY,CAAC,EAAE,CAAA;IAC/D,UAAU,EAAE,OAAO,GAAG,OAAO,CAAA;IAC7B,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,OAAO,GAAI,qDAMrB,WAAW,KAAG,QA0EhB,CAAA"}

package/esm/parse/v3-0/union/toUnion.js

@@ -0,0 +1,66 @@
+import { OasUnion } from '../../../oas/union/Union.js';
+import { toDiscriminatorV3 } from '../discriminator/toDiscriminatorV3.js';
+import { toSchemaV3 } from '../schema/toSchemasV3.js';
+import { toSpecificationExtensionsV3 } from '../specificationExtensions/toSpecificationExtensionsV3.js';
+import { parseNullable } from '../_helpers/parseNullable.js';
+import { parseExample } from '../_helpers/parseExample.js';
+import { parseDefault } from '../_helpers/parseDefault.js';
+export const toUnion = ({ value, members, parentType, stackTrail, context }) => {
+    const { nullable, value: valueWithoutNullable } = parseNullable({
+        value,
+        context,
+        stackTrail
+    });
+    const { discriminator, title, description, example: unparsedExample, default: unparsedDefaultValue, ...skipped } = valueWithoutNullable;
+    const example = parseExample({
+        value: unparsedExample,
+        context,
+        parent: value,
+        nullable,
+        check: isPresent,
+        toMessage: item => `Removed invalid example. Expected a non-null value, got: ${item}`,
+        stackTrail
+    });
+    const defaultValue = parseDefault({
+        value: unparsedDefaultValue,
+        context,
+        parent: value,
+        nullable,
+        check: isPresent,
+        toMessage: item => `Removed invalid default. Expected a non-null value, got: ${item}`,
+        stackTrail
+    });
+    const extensionFields = toSpecificationExtensionsV3({
+        skipped,
+        parent: value,
+        context,
+        stackTrail,
+        parentType: `schema:${parentType}`
+    });
+    const discriminatorParsed = stackTrail.trace('discriminator', st => toDiscriminatorV3({ discriminator, stackTrail: st, context }));
+    const membersParsed = members.reduce((acc, item, index) => {
+        if (item === undefined || item === null) {
+            return acc;
+        }
+        return [
+            ...acc,
+            stackTrail.trace(`${index}`, st => toSchemaV3({ schema: item, stackTrail: st, context }))
+        ];
+    }, []);
+    return context.withStackTrail(stackTrail, () => new OasUnion({
+        title,
+        description,
+        nullable,
+        default: defaultValue,
+        discriminator: discriminatorParsed,
+        members: membersParsed,
+        example,
+        extensionFields
+    }, context));
+};
+// A union (anyOf/oneOf) value may match any of its members, so the most we
+// can validate without resolving members is that a present default/example
+// is not a bare `null` on a non-nullable schema.
+const isPresent = (value) => {
+    return value !== null && value !== undefined;
+};

package/esm/parse/v3-0/unknown/toUnknown.d.ts

@@ -0,0 +1,11 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasUnknown } from '../../../oas/unknown/Unknown.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToUnknownArgs = {
+    value: OpenAPIV3.SchemaObject;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toUnknown: ({ value, stackTrail, context }: ToUnknownArgs) => OasUnknown;
+//# sourceMappingURL=toUnknown.d.ts.map

package/esm/parse/v3-0/unknown/toUnknown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toUnknown.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-0/unknown/toUnknown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAE5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAEhE,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,SAAS,CAAC,YAAY,CAAA;IAC7B,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,gCAAgC,aAAa,KAAG,UAuBzE,CAAA"}

package/esm/parse/v3-0/unknown/toUnknown.js

@@ -0,0 +1,19 @@
+import { OasUnknown } from '../../../oas/unknown/Unknown.js';
+import { toSpecificationExtensionsV3 } from '../specificationExtensions/toSpecificationExtensionsV3.js';
+export const toUnknown = ({ value, stackTrail, context }) => {
+    const { type: _type, title, description, example, nullable, ...skipped } = value;
+    const extensionFields = toSpecificationExtensionsV3({
+        skipped,
+        parent: value,
+        context,
+        stackTrail,
+        parentType: 'schema:unknown'
+    });
+    return context.withStackTrail(stackTrail, () => new OasUnknown({
+        title,
+        description,
+        nullable,
+        extensionFields,
+        example
+    }, context));
+};

package/esm/parse/v3-0/webhook/toWebhooksV3.d.ts

@@ -0,0 +1,49 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { Method } from '../../../types/Method.js';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasWebhook } from '../../../oas/webhook/Webhook.js';
+import type { OasPathItem } from '../../../oas/pathItem/PathItem.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+/**
+ * The 3.1 `webhooks` object: a map of webhook NAME → PathItem, identical
+ * in shape to `paths` but keyed by name rather than URL path. Inline
+ * PathItems only — a webhook PathItem `$ref` is a 3.1 edge case not yet
+ * handled (see the arc note §5 Refs).
+ */
+export type WebhooksObject = Record<string, OpenAPIV3.PathItemObject>;
+type WebhookInfo = {
+    method: Method;
+    name: string;
+    pathItem: OasPathItem | undefined;
+};
+export type ToWebhookV3Args = {
+    operation: OpenAPIV3.OperationObject;
+    webhookInfo: WebhookInfo;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+/**
+ * Parses a single webhook Operation Object into an {@link OasWebhook}.
+ *
+ * Mirrors `toOperationV3` and reuses the same leaf field parsers
+ * (`toParameterListV3` / `toRequestBodyV3` / `toResponsesV3` / …) — the
+ * inner Operation Object is structurally identical. Only the orchestration
+ * is duplicated (the dialect-shaped glue), and the output is an
+ * `OasWebhook` carrying a `name`, not an `OasOperation` carrying a `path`.
+ */
+export declare const toWebhookV3: ({ operation, webhookInfo, stackTrail, context }: ToWebhookV3Args) => OasWebhook;
+export type ToWebhooksV3Args = {
+    webhooks: WebhooksObject | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+/**
+ * Flattens the 3.1 `webhooks` map into `OasWebhook[]`, mirroring
+ * `toOperationsV3`'s `paths` → `OasOperation[]` flattening. Returns `[]`
+ * when no `webhooks` object is present (the common 3.0 / no-webhook case).
+ * The stack trail nests `webhooks` → `<name>` → `<method>` so
+ * `OasDocument.removeItem` can locate a webhook by name.
+ */
+export declare const toWebhooksV3: ({ webhooks, stackTrail, context }: ToWebhooksV3Args) => OasWebhook[];
+export {};
+//# sourceMappingURL=toWebhooksV3.d.ts.map

package/esm/parse/v3-0/webhook/toWebhooksV3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toWebhooksV3.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-0/webhook/toWebhooksV3.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAA;AACtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AAItE,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAE5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAA;AAOpE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAEhE;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,cAAc,CAAC,CAAA;AAErE,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,WAAW,GAAG,SAAS,CAAA;CAClC,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,SAAS,EAAE,SAAS,CAAC,eAAe,CAAA;IACpC,WAAW,EAAE,WAAW,CAAA;IACxB,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAOD;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,GAAI,iDAKzB,eAAe,KAAG,UAmEpB,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,EAAE,cAAc,GAAG,SAAS,CAAA;IACpC,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,GAAI,mCAI1B,gBAAgB,KAAG,UAAU,EA+E/B,CAAA"}