@skmtc/core 0.0.984 → 0.16.2

package/esm/oas/webhook/Webhook.js

@@ -0,0 +1,224 @@
+import "../../_dnt.polyfills.js";
+import { OasBase } from '../../types/OasBase.js';
+/**
+ * Represents an OpenAPI 3.1 webhook — a third OAS subject, peer to
+ * {@link OasOperation} and the schema/model subjects.
+ *
+ * Kept OUT of {@link OasDocument.operations} (it lives in
+ * {@link OasDocument.webhooks}) so existing client/SDK generators never
+ * receive one: webhook code generation is a *receiver/handler* concern,
+ * not a client-call concern.
+ *
+ * Carries webhook-semantic accessors named for the RECEIVER —
+ * `toPayload`/`toPayloadSchema` (the received payload), `toParams` (inbound
+ * params), `toAckResponse`/`toAckResponseCode` (the ack the handler returns).
+ * These deliberately avoid the client-framed {@link OasOperation} names
+ * (`toRequestBody`, `toSuccessResponse`) so the inversion stays explicit in
+ * generator code. (Signature-verification helpers still accrue on demand.)
+ */
+export class OasWebhook extends OasBase {
+    constructor(fields, context) {
+        super(context);
+        /** Type identifier for OAS webhook objects */
+        Object.defineProperty(this, "oasType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'webhook'
+        });
+        /** The webhook name (the `webhooks` map key — NOT a URL path) */
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** The HTTP method for this webhook */
+        Object.defineProperty(this, "method", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** The parent path item containing this webhook */
+        Object.defineProperty(this, "pathItem", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Unique identifier for the webhook operation */
+        Object.defineProperty(this, "operationId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Brief summary of the webhook */
+        Object.defineProperty(this, "summary", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Tags for organizing webhooks in documentation */
+        Object.defineProperty(this, "tags", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Detailed description of the webhook */
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Parameters accepted by this webhook */
+        Object.defineProperty(this, "parameters", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Payload delivered to the handler for this webhook */
+        Object.defineProperty(this, "requestBody", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Acknowledgement responses mapped by status code */
+        Object.defineProperty(this, "responses", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Security requirements for this webhook */
+        Object.defineProperty(this, "security", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Whether this webhook is deprecated */
+        Object.defineProperty(this, "deprecated", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** External documentation for this webhook */
+        Object.defineProperty(this, "externalDocs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** OpenAPI specification extensions */
+        Object.defineProperty(this, "extensionFields", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Servers for this webhook */
+        Object.defineProperty(this, "servers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = fields.name;
+        this.method = fields.method;
+        this.pathItem = fields.pathItem;
+        this.operationId = fields.operationId;
+        this.summary = fields.summary;
+        this.tags = fields.tags;
+        this.description = fields.description;
+        this.parameters = fields.parameters;
+        this.requestBody = fields.requestBody;
+        this.responses = fields.responses;
+        this.security = fields.security;
+        this.deprecated = fields.deprecated;
+        this.externalDocs = fields.externalDocs;
+        this.extensionFields = fields.extensionFields;
+        this.servers = fields.servers;
+    }
+    /**
+     * The received-payload body — the request body the API delivers TO the
+     * consumer's handler. Webhook semantics are inverted: this is what the
+     * handler RECEIVES, not what a client sends. A `$ref` body is resolved.
+     */
+    toPayload() {
+        return this.requestBody?.resolve();
+    }
+    /**
+     * The schema of the received payload for `mediaType` (default
+     * `application/json`) — the inbound body shape a handler generator emits a
+     * type for. `undefined` when there is no body or no schema for that media
+     * type.
+     */
+    toPayloadSchema(mediaType = 'application/json') {
+        return this.toPayload()?.content[mediaType]?.schema;
+    }
+    /**
+     * Resolve the inbound parameters (e.g. the signature/headers a handler
+     * receives), optionally filtered by location. Mirrors
+     * {@link OasOperation.toParams}; the parameters carry the same shape, only
+     * their direction is inbound.
+     */
+    toParams(filter) {
+        return (this.parameters
+            ?.map(param => param.resolve())
+            .filter(param => (filter?.length ? filter.includes(param.location) : true)) ?? []);
+    }
+    /**
+     * The status code of the primary acknowledgement response — the lowest 2xx
+     * the handler returns to ack the delivery, falling back to `default`. Named
+     * for the receiver: a webhook's `responses` are what the handler RETURNS,
+     * not what a client receives (cf. {@link OasOperation.toSuccessResponseCode}).
+     */
+    toAckResponseCode() {
+        const ackCode = Object.keys(this.responses)
+            .map(httpCode => parseInt(httpCode))
+            .sort((a, b) => a - b)
+            .find(httpCode => httpCode >= 200 && httpCode < 300);
+        if (ackCode) {
+            return ackCode.toString();
+        }
+        if (this.responses.default) {
+            return 'default';
+        }
+        return undefined;
+    }
+    /**
+     * The primary acknowledgement response definition (the body/headers the
+     * handler returns), or `undefined` when none is declared.
+     */
+    toAckResponse() {
+        const ackCode = this.toAckResponseCode();
+        return ackCode ? this.responses[ackCode] : undefined;
+    }
+    /**
+     * Serializes the webhook to a plain JavaScript object.
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            method: this.method,
+            operationId: this.operationId,
+            summary: this.summary,
+            description: this.description,
+            tags: this.tags,
+            parameters: this.parameters,
+            requestBody: this.requestBody,
+            responses: this.responses,
+            security: this.security,
+            deprecated: this.deprecated,
+            ...this.extensionFields
+        };
+    }
+}

package/esm/parse/toOasDialect.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The OpenAPI dialects SKMTC parses natively. Each has its own complete
+ * parser tree (`core/parse/v3-0`, `core/parse/v3-1`); this module is the
+ * ONLY place a document's version is examined. Once a dialect is chosen
+ * the matching parser runs top-to-bottom and never re-checks the version,
+ * so a 3.0 document can never reach a line of 3.1 logic (or vice versa) —
+ * there is no downstream version branch to get wrong.
+ */
+export type OasDialect = '3.0' | '3.1';
+/**
+ * Map an OpenAPI document's `openapi` version string to its parser
+ * dialect.
+ *
+ * Detection is EXPLICIT and fails LOUD: an unknown or missing version is a
+ * precondition failure — there is no sensible parser to pick — so it throws
+ * rather than silently defaulting to one dialect and masking the error. A
+ * loose `openapi.startsWith('3.1') ? '3.1' : '3.0'` would route every
+ * non-3.1 value (a typo, `3.2`, `4.0`, a missing field) into 3.0 unnoticed;
+ * that is the footgun this avoids. Mirrors `@skmtc/convert`'s
+ * `toV3Document`, which likewise throws on an unrecognized version.
+ *
+ * OpenAPI 2.0 (Swagger) never reaches here: `swagger2openapi` upgrades it
+ * to 3.0 upstream, host-side, before the document is parsed.
+ */
+export declare const toOasDialect: (openapi: string | undefined) => OasDialect;
+//# sourceMappingURL=toOasDialect.d.ts.map

package/esm/parse/toOasDialect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toOasDialect.d.ts","sourceRoot":"","sources":["../../src/parse/toOasDialect.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,KAAK,CAAA;AAEtC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,YAAY,GAAI,SAAS,MAAM,GAAG,SAAS,KAAG,UAO1D,CAAA"}

package/esm/parse/toOasDialect.js

@@ -0,0 +1,22 @@
+/**
+ * Map an OpenAPI document's `openapi` version string to its parser
+ * dialect.
+ *
+ * Detection is EXPLICIT and fails LOUD: an unknown or missing version is a
+ * precondition failure — there is no sensible parser to pick — so it throws
+ * rather than silently defaulting to one dialect and masking the error. A
+ * loose `openapi.startsWith('3.1') ? '3.1' : '3.0'` would route every
+ * non-3.1 value (a typo, `3.2`, `4.0`, a missing field) into 3.0 unnoticed;
+ * that is the footgun this avoids. Mirrors `@skmtc/convert`'s
+ * `toV3Document`, which likewise throws on an unrecognized version.
+ *
+ * OpenAPI 2.0 (Swagger) never reaches here: `swagger2openapi` upgrades it
+ * to 3.0 upstream, host-side, before the document is parsed.
+ */
+export const toOasDialect = (openapi) => {
+    if (openapi?.startsWith('3.0'))
+        return '3.0';
+    if (openapi?.startsWith('3.1'))
+        return '3.1';
+    throw new Error(`Unsupported OpenAPI version: ${openapi ?? '(missing)'} — expected 3.0.x or 3.1.x`);
+};

package/esm/parse/v3-0/_helpers/parseDefault.d.ts

@@ -0,0 +1,44 @@
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+/**
+ * Arguments for parsing the `default` property from OpenAPI schemas.
+ *
+ * @template Value - The narrowed type a valid (non-null) default holds
+ */
+export type ParseDefaultArgs<Value> = {
+    /** The raw `default` value extracted from the schema */
+    value: unknown;
+    /** The parsed nullable flag — `null` is only a valid default when this is `true` */
+    nullable: boolean | undefined;
+    /** The surrounding schema object, used as the issue location's parent */
+    parent: unknown;
+    /** Type guard narrowing an acceptable non-null default to `Value` */
+    check: (item: unknown) => item is Value;
+    /** Builds the warning message for a rejected default */
+    toMessage: (item: unknown) => string;
+    /** Parse context for logging issues */
+    context: ParseContextType;
+    /** Stack trail for tracking the current parsing location */
+    stackTrail: StackTrail;
+};
+/**
+ * Parses and validates the `default` property of an OpenAPI scalar/structural
+ * schema, applying the nullable-conditional rule shared by `example`, `enum`,
+ * and `default`:
+ *
+ * - `undefined` → `undefined` (no default present)
+ * - `null` → kept only when `nullable` is `true`; otherwise rejected
+ * - a value passing `check` → kept
+ * - anything else → logged as an `INVALID_DEFAULT` warning and dropped
+ *
+ * This mirrors the OpenAPI 3.0 rule that a `default` MUST conform to the
+ * schema's type, where `nullable: true` widens that type to include `null`.
+ * The function is fail-open: an invalid default is stripped and recorded as a
+ * `ParseIssue`, never thrown.
+ *
+ * @template Value - The narrowed type a valid default holds
+ * @param args - Parsing configuration
+ * @returns The validated default (`Value`), `null` (nullable), or `undefined`
+ */
+export declare const parseDefault: <Value>({ value, nullable, parent, context, check, toMessage, stackTrail }: ParseDefaultArgs<Value>) => Value | null | undefined;
+//# sourceMappingURL=parseDefault.d.ts.map

package/esm/parse/v3-0/_helpers/parseDefault.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseDefault.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-0/_helpers/parseDefault.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAEhE;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,CAAC,KAAK,IAAI;IACpC,wDAAwD;IACxD,KAAK,EAAE,OAAO,CAAA;IACd,oFAAoF;IACpF,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAA;IAC7B,yEAAyE;IACzE,MAAM,EAAE,OAAO,CAAA;IACf,qEAAqE;IACrE,KAAK,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,IAAI,KAAK,CAAA;IACvC,wDAAwD;IACxD,SAAS,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,MAAM,CAAA;IACpC,uCAAuC;IACvC,OAAO,EAAE,gBAAgB,CAAA;IACzB,4DAA4D;IAC5D,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,YAAY,GAAI,KAAK,EAAE,oEAQjC,gBAAgB,CAAC,KAAK,CAAC,KAAG,KAAK,GAAG,IAAI,GAAG,SAuB3C,CAAA"}

package/esm/parse/v3-0/_helpers/parseDefault.js

@@ -0,0 +1,39 @@
+/**
+ * Parses and validates the `default` property of an OpenAPI scalar/structural
+ * schema, applying the nullable-conditional rule shared by `example`, `enum`,
+ * and `default`:
+ *
+ * - `undefined` → `undefined` (no default present)
+ * - `null` → kept only when `nullable` is `true`; otherwise rejected
+ * - a value passing `check` → kept
+ * - anything else → logged as an `INVALID_DEFAULT` warning and dropped
+ *
+ * This mirrors the OpenAPI 3.0 rule that a `default` MUST conform to the
+ * schema's type, where `nullable: true` widens that type to include `null`.
+ * The function is fail-open: an invalid default is stripped and recorded as a
+ * `ParseIssue`, never thrown.
+ *
+ * @template Value - The narrowed type a valid default holds
+ * @param args - Parsing configuration
+ * @returns The validated default (`Value`), `null` (nullable), or `undefined`
+ */
+export const parseDefault = ({ value, nullable, parent, context, check, toMessage, stackTrail }) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (nullable && value === null) {
+        return null;
+    }
+    if (!check(value)) {
+        context.logIssue({
+            key: 'default',
+            level: 'warning',
+            message: toMessage(value),
+            parent,
+            stackTrail,
+            type: 'INVALID_DEFAULT'
+        });
+        return undefined;
+    }
+    return value;
+};

package/esm/parse/v3-0/_helpers/parseEnum.d.ts

@@ -0,0 +1,14 @@
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+type ParseEnumArgs = {
+    value: unknown;
+    nullable: boolean | undefined;
+    parent: unknown;
+    check: (item: unknown) => boolean;
+    toMessage: (item: unknown) => string;
+    context: ParseContextType;
+    stackTrail: StackTrail;
+};
+export declare const parseEnum: ({ value, nullable, parent, context, check, toMessage, stackTrail }: ParseEnumArgs) => any[] | undefined;
+export {};
+//# sourceMappingURL=parseEnum.d.ts.map

package/esm/parse/v3-0/_helpers/parseEnum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseEnum.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-0/_helpers/parseEnum.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAEhE,KAAK,aAAa,GAAG;IACnB,KAAK,EAAE,OAAO,CAAA;IACd,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAA;IAC7B,MAAM,EAAE,OAAO,CAAA;IACf,KAAK,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAA;IACjC,SAAS,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,MAAM,CAAA;IACpC,OAAO,EAAE,gBAAgB,CAAA;IACzB,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,oEAQvB,aAAa,sBA2Bf,CAAA"}

package/esm/parse/v3-0/_helpers/parseEnum.js

@@ -0,0 +1,23 @@
+export const parseEnum = ({ value, nullable, parent, context, check, toMessage, stackTrail }) => {
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            if (nullable && item === null) {
+                continue;
+            }
+            if (check(item)) {
+                continue;
+            }
+            context.logIssue({
+                key: 'enum',
+                level: 'warning',
+                message: toMessage(item),
+                parent,
+                stackTrail,
+                type: 'INVALID_ENUM'
+            });
+            return undefined;
+        }
+        return value;
+    }
+    return undefined;
+};

package/esm/parse/v3-0/_helpers/parseExample.d.ts

@@ -0,0 +1,42 @@
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+/**
+ * Arguments for parsing the `example` property from OpenAPI schemas.
+ *
+ * @template Value - The narrowed type a valid (non-null) example holds
+ */
+export type ParseExampleArgs<Value> = {
+    /** The raw `example` value extracted from the schema */
+    value: unknown;
+    /** The parsed nullable flag — `null` is only a valid example when this is `true` */
+    nullable: boolean | undefined;
+    /** The surrounding schema object, used as the issue location's parent */
+    parent: unknown;
+    /** Type guard narrowing an acceptable non-null example to `Value` */
+    check: (item: unknown) => item is Value;
+    /** Builds the warning message for a rejected example */
+    toMessage: (item: unknown) => string;
+    /** Parse context for logging issues */
+    context: ParseContextType;
+    /** Stack trail for tracking the current parsing location */
+    stackTrail: StackTrail;
+};
+/**
+ * Parses and validates the `example` property of an OpenAPI scalar/structural
+ * schema, applying the nullable-conditional rule shared by `example`, `enum`,
+ * and `default`:
+ *
+ * - `undefined` → `undefined` (no example present)
+ * - `null` → kept only when `nullable` is `true`; otherwise rejected
+ * - a value passing `check` → kept
+ * - anything else → logged as an `INVALID_EXAMPLE` warning and dropped
+ *
+ * The function is fail-open: an invalid example is stripped and recorded as a
+ * `ParseIssue`, never thrown.
+ *
+ * @template Value - The narrowed type a valid example holds
+ * @param args - Parsing configuration
+ * @returns The validated example (`Value`), `null` (nullable), or `undefined`
+ */
+export declare const parseExample: <Value>({ value, nullable, parent, context, check, toMessage, stackTrail }: ParseExampleArgs<Value>) => Value | null | undefined;
+//# sourceMappingURL=parseExample.d.ts.map

package/esm/parse/v3-0/_helpers/parseExample.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseExample.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-0/_helpers/parseExample.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAEhE;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,CAAC,KAAK,IAAI;IACpC,wDAAwD;IACxD,KAAK,EAAE,OAAO,CAAA;IACd,oFAAoF;IACpF,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAA;IAC7B,yEAAyE;IACzE,MAAM,EAAE,OAAO,CAAA;IACf,qEAAqE;IACrE,KAAK,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,IAAI,KAAK,CAAA;IACvC,wDAAwD;IACxD,SAAS,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,MAAM,CAAA;IACpC,uCAAuC;IACvC,OAAO,EAAE,gBAAgB,CAAA;IACzB,4DAA4D;IAC5D,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,YAAY,GAAI,KAAK,EAAE,oEAQjC,gBAAgB,CAAC,KAAK,CAAC,KAAG,KAAK,GAAG,IAAI,GAAG,SAuB3C,CAAA"}

package/esm/parse/v3-0/_helpers/parseExample.js

@@ -0,0 +1,37 @@
+/**
+ * Parses and validates the `example` property of an OpenAPI scalar/structural
+ * schema, applying the nullable-conditional rule shared by `example`, `enum`,
+ * and `default`:
+ *
+ * - `undefined` → `undefined` (no example present)
+ * - `null` → kept only when `nullable` is `true`; otherwise rejected
+ * - a value passing `check` → kept
+ * - anything else → logged as an `INVALID_EXAMPLE` warning and dropped
+ *
+ * The function is fail-open: an invalid example is stripped and recorded as a
+ * `ParseIssue`, never thrown.
+ *
+ * @template Value - The narrowed type a valid example holds
+ * @param args - Parsing configuration
+ * @returns The validated example (`Value`), `null` (nullable), or `undefined`
+ */
+export const parseExample = ({ value, nullable, parent, context, check, toMessage, stackTrail }) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (nullable && value === null) {
+        return null;
+    }
+    if (!check(value)) {
+        context.logIssue({
+            key: 'example',
+            level: 'warning',
+            message: toMessage(value),
+            parent,
+            stackTrail,
+            type: 'INVALID_EXAMPLE'
+        });
+        return undefined;
+    }
+    return value;
+};

package/esm/parse/v3-0/_helpers/parseNullable.d.ts

@@ -0,0 +1,142 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+/**
+ * Arguments for parsing the nullable property from OpenAPI schemas.
+ *
+ * @template Value - The OpenAPI schema object type
+ */
+export type ParseNullableArgs<Value extends OpenAPIV3.SchemaObject> = {
+    /** The OpenAPI schema object containing the nullable property */
+    value: Value;
+    /** Stack trail for tracking current parsing context */
+    stackTrail: StackTrail;
+    /** Parse context for error handling */
+    context: ParseContextType;
+};
+/**
+ * Return type for parsed nullable data.
+ *
+ * @template Value - The OpenAPI schema object type
+ */
+export type ParseNullableReturn<Value extends OpenAPIV3.SchemaObject> = {
+    /** The validated nullable flag (true, false, or undefined) */
+    nullable: boolean | undefined;
+    /** The schema object without the nullable property */
+    value: Omit<Value, 'nullable'>;
+};
+/**
+ * Parses and validates the nullable property from OpenAPI schema objects.
+ *
+ * This function extracts and validates the `nullable` property from OpenAPI
+ * schema objects, ensuring it's a valid boolean value. Invalid nullable values
+ * are removed and logged as warnings through the parse context.
+ *
+ * The nullable property determines whether a schema value can be null in addition
+ * to its primary type, which affects type generation and validation logic.
+ *
+ * @template Value - The OpenAPI schema object type
+ *
+ * @param args - Parsing configuration
+ * @returns Parsed nullable data with the validated flag and cleaned schema
+ *
+ * @example Valid nullable property
+ * ```typescript
+ * import { parseNullable } from '@skmtc/core/oas/_helpers';
+ *
+ * const result = parseNullable({
+ *   value: {
+ *     type: 'string',
+ *     nullable: true,
+ *     description: 'An optional string that can be null'
+ *   },
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.nullable); // true
+ * console.log(result.value);    // { type: 'string', description: 'An optional string that can be null' }
+ * ```
+ *
+ * @example Explicitly non-nullable
+ * ```typescript
+ * const result = parseNullable({
+ *   value: {
+ *     type: 'number',
+ *     nullable: false,
+ *     minimum: 0
+ *   },
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.nullable); // false
+ * console.log(result.value);    // { type: 'number', minimum: 0 }
+ * ```
+ *
+ * @example Missing nullable property (undefined)
+ * ```typescript
+ * const result = parseNullable({
+ *   value: {
+ *     type: 'string',
+ *     format: 'email'
+ *   },
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.nullable); // undefined (property not present)
+ * console.log(result.value);    // { type: 'string', format: 'email' }
+ * ```
+ *
+ * @example Invalid nullable value
+ * ```typescript
+ * const result = parseNullable({
+ *   value: {
+ *     type: 'boolean',
+ *     nullable: 'yes', // Invalid - should be boolean
+ *     description: 'A flag'
+ *   } as any,
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.nullable); // undefined (invalid value removed)
+ * console.log(result.value);    // { type: 'boolean', description: 'A flag' }
+ * // Context will log a warning about the invalid nullable value
+ * ```
+ *
+ * @example Usage in type generation
+ * ```typescript
+ * function generateTypeScript(schema: OpenAPIV3.SchemaObject) {
+ *   const { nullable, value } = parseNullable({ value: schema, context });
+ *
+ *   const baseType = generateBaseType(value);
+ *   const nullableType = nullable ? ` | null` : '';
+ *
+ *   return `${baseType}${nullableType}`;
+ * }
+ *
+ * // Examples:
+ * // nullable: true  -> 'string | null'
+ * // nullable: false -> 'string'
+ * // nullable: undefined -> 'string' (default behavior)
+ * ```
+ *
+ * @example Complex schema with nullable
+ * ```typescript
+ * const result = parseNullable({
+ *   value: {
+ *     type: 'object',
+ *     properties: {
+ *       name: { type: 'string' },
+ *       age: { type: 'number' }
+ *     },
+ *     required: ['name'],
+ *     nullable: true // The entire object can be null
+ *   },
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.nullable); // true
+ * // Generated type might be: { name: string; age?: number } | null
+ * ```
+ */
+export declare const parseNullable: <Value extends OpenAPIV3.SchemaObject>({ value, stackTrail, context }: ParseNullableArgs<Value>) => ParseNullableReturn<Value>;
+//# sourceMappingURL=parseNullable.d.ts.map

package/esm/parse/v3-0/_helpers/parseNullable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseNullable.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-0/_helpers/parseNullable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAEhE;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,CAAC,KAAK,SAAS,SAAS,CAAC,YAAY,IAAI;IACpE,iEAAiE;IACjE,KAAK,EAAE,KAAK,CAAA;IACZ,uDAAuD;IACvD,UAAU,EAAE,UAAU,CAAA;IACtB,uCAAuC;IACvC,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,CAAC,KAAK,SAAS,SAAS,CAAC,YAAY,IAAI;IACtE,8DAA8D;IAC9D,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAA;IAC7B,sDAAsD;IACtD,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,UAAU,CAAC,CAAA;CAC/B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgHG;AACH,eAAO,MAAM,aAAa,GAAI,KAAK,SAAS,SAAS,CAAC,YAAY,EAAE,gCAIjE,iBAAiB,CAAC,KAAK,CAAC,KAAG,mBAAmB,CAAC,KAAK,CA8BtD,CAAA"}

package/esm/parse/v3-0/_merge-all-of/check-array-item-type-conflicts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-array-item-type-conflicts.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-0/_merge-all-of/check-array-item-type-conflicts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAE9C,eAAO,MAAM,2BAA2B,GACtC,GAAG,SAAS,CAAC,YAAY,EACzB,GAAG,SAAS,CAAC,YAAY,KACxB,IAUF,CAAA"}

package/esm/parse/v3-0/_merge-all-of/check-at-least-one-type-match.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-at-least-one-type-match.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-0/_merge-all-of/check-at-least-one-type-match.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE9C,KAAK,UAAU,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,OAAO,CAAA;AAElF,eAAO,MAAM,wBAAwB,GACnC,OAAO,YAAY,EACnB,QAAQ,YAAY,EACpB,MAAM,UAAU,KACf,OAMF,CAAA"}

package/esm/parse/v3-0/_merge-all-of/check-enum-conflicts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-enum-conflicts.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-0/_merge-all-of/check-enum-conflicts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAE9C,eAAO,MAAM,kBAAkB,GAC7B,OAAO,SAAS,CAAC,YAAY,EAC7B,QAAQ,SAAS,CAAC,YAAY,KAC7B,IAYF,CAAA"}

package/esm/parse/v3-0/_merge-all-of/check-format-conflicts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-format-conflicts.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-0/_merge-all-of/check-format-conflicts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAE9C,eAAO,MAAM,oBAAoB,GAC/B,GAAG,SAAS,CAAC,YAAY,EACzB,GAAG,SAAS,CAAC,YAAY,KACxB,IAIF,CAAA"}

package/esm/parse/v3-0/_merge-all-of/check-number-constraints-conflicts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-number-constraints-conflicts.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-0/_merge-all-of/check-number-constraints-conflicts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAE9C,eAAO,MAAM,+BAA+B,GAC1C,GAAG,SAAS,CAAC,YAAY,EACzB,GAAG,SAAS,CAAC,YAAY,KACxB,IAYF,CAAA"}

package/esm/parse/v3-0/_merge-all-of/check-read-only-write-only-conflicts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-read-only-write-only-conflicts.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-0/_merge-all-of/check-read-only-write-only-conflicts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAE9C,eAAO,MAAM,+BAA+B,GAC1C,GAAG,SAAS,CAAC,YAAY,EACzB,GAAG,SAAS,CAAC,YAAY,KACxB,IAIF,CAAA"}

package/esm/parse/v3-0/_merge-all-of/check-type-conflicts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-type-conflicts.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-0/_merge-all-of/check-type-conflicts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAE9C,eAAO,MAAM,kBAAkB,GAC7B,OAAO,SAAS,CAAC,YAAY,EAC7B,QAAQ,SAAS,CAAC,YAAY,KAC7B,IAQF,CAAA"}