@skmtc/core 0.28.7 → 0.30.1

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

@@ -0,0 +1,43 @@
+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;

package/esm/parse/v3-2/_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-2/_helpers/parseEnum.d.ts

@@ -0,0 +1,13 @@
+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 {};

package/esm/parse/v3-2/_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-2/_helpers/parseExample.d.ts

@@ -0,0 +1,41 @@
+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;

package/esm/parse/v3-2/_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-2/_helpers/parseNullable.d.ts

@@ -0,0 +1,141 @@
+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>;

package/esm/parse/v3-2/_helpers/parseNullable.js

@@ -0,0 +1,140 @@
+/**
+ * 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 const parseNullable = ({ value, stackTrail, context }) => {
+    if (value.nullable === undefined) {
+        return {
+            nullable: undefined,
+            value: value
+        };
+    }
+    const { nullable, ...rest } = value;
+    if (typeof nullable === 'boolean') {
+        return {
+            nullable: nullable,
+            value: rest
+        };
+    }
+    context.logIssue({
+        key: 'nullable',
+        stackTrail,
+        parent: value,
+        level: 'warning',
+        message: `Invalid nullable: ${value}`,
+        type: 'INVALID_NULLABLE'
+    });
+    return {
+        nullable: undefined,
+        value: rest
+    };
+};

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

@@ -0,0 +1,2 @@
+import type { OpenAPIV3 } from 'openapi-types';
+export declare const checkArrayItemTypeConflicts: (a: OpenAPIV3.SchemaObject, b: OpenAPIV3.SchemaObject) => void;

package/esm/parse/v3-2/_merge-all-of/check-array-item-type-conflicts.js

@@ -0,0 +1,9 @@
+export const checkArrayItemTypeConflicts = (a, b) => {
+    if (a.type === 'array' && b.type === 'array' && 'items' in a && 'items' in b) {
+        const aItems = a.items;
+        const bItems = b.items;
+        if (aItems.type && bItems.type && aItems.type !== bItems.type) {
+            throw new Error(`Cannot merge schemas: array items have conflicting types '${aItems.type}' and '${bItems.type}'`);
+        }
+    }
+};

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

@@ -0,0 +1,4 @@
+import type { SchemaObject } from './types.js';
+type SchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array';
+export declare const checkAtLeastOneTypeMatch: (first: SchemaObject, second: SchemaObject, type: SchemaType) => boolean;
+export {};

package/esm/parse/v3-2/_merge-all-of/check-at-least-one-type-match.js

@@ -0,0 +1,5 @@
+export const checkAtLeastOneTypeMatch = (first, second, type) => {
+    return ((first.type === type && second.type === type) ||
+        (first.type === type && !second.type) ||
+        (!first.type && second.type === type));
+};

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

@@ -0,0 +1,2 @@
+import type { OpenAPIV3 } from 'openapi-types';
+export declare const checkEnumConflicts: (first: OpenAPIV3.SchemaObject, second: OpenAPIV3.SchemaObject) => void;

package/esm/parse/v3-2/_merge-all-of/check-enum-conflicts.js

@@ -0,0 +1,11 @@
+import { isEqual } from './is-equal.js';
+export const checkEnumConflicts = (first, second) => {
+    if (first.enum && second.enum) {
+        const intersection = first.enum.filter(value => {
+            return second.enum.some(bValue => isEqual(value, bValue));
+        });
+        if (intersection.length === 0) {
+            throw new Error(`Cannot merge schemas: enum values have no intersection. First: ${first.enum}, Second: ${second.enum}`);
+        }
+    }
+};

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

@@ -0,0 +1,2 @@
+import type { OpenAPIV3 } from 'openapi-types';
+export declare const checkFormatConflicts: (a: OpenAPIV3.SchemaObject, b: OpenAPIV3.SchemaObject) => void;

package/esm/parse/v3-2/_merge-all-of/check-format-conflicts.js

@@ -0,0 +1,5 @@
+export const checkFormatConflicts = (a, b) => {
+    if (a.format && b.format && a.format !== b.format) {
+        throw new Error(`Cannot merge schemas: conflicting formats '${a.format}' and '${b.format}'`);
+    }
+};

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

@@ -0,0 +1,2 @@
+import type { OpenAPIV3 } from 'openapi-types';
+export declare const checkNumberConstraintsConflicts: (a: OpenAPIV3.SchemaObject, b: OpenAPIV3.SchemaObject) => void;

package/esm/parse/v3-2/_merge-all-of/check-number-constraints-conflicts.js

@@ -0,0 +1,11 @@
+export const checkNumberConstraintsConflicts = (a, b) => {
+    if (a.type === 'number' && b.type === 'number') {
+        const aMin = a.minimum ?? -Infinity;
+        const aMax = a.maximum ?? Infinity;
+        const bMin = b.minimum ?? -Infinity;
+        const bMax = b.maximum ?? Infinity;
+        if (aMin > bMax || bMin > aMax) {
+            throw new Error(`Cannot merge schemas: incompatible number ranges [${aMin},${aMax}] and [${bMin},${bMax}]`);
+        }
+    }
+};

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

@@ -0,0 +1,2 @@
+import type { OpenAPIV3 } from 'openapi-types';
+export declare const checkReadOnlyWriteOnlyConflicts: (a: OpenAPIV3.SchemaObject, b: OpenAPIV3.SchemaObject) => void;

package/esm/parse/v3-2/_merge-all-of/check-read-only-write-only-conflicts.js

@@ -0,0 +1,5 @@
+export const checkReadOnlyWriteOnlyConflicts = (a, b) => {
+    if ((a.readOnly && b.writeOnly) || (a.writeOnly && b.readOnly)) {
+        throw new Error('Cannot merge schemas: property cannot be both readOnly and writeOnly');
+    }
+};

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

@@ -0,0 +1,2 @@
+import type { OpenAPIV3 } from 'openapi-types';
+export declare const checkTypeConflicts: (first: OpenAPIV3.SchemaObject, second: OpenAPIV3.SchemaObject) => void;

package/esm/parse/v3-2/_merge-all-of/check-type-conflicts.js

@@ -0,0 +1,5 @@
+export const checkTypeConflicts = (first, second) => {
+    if (first.type && second.type && first.type !== second.type) {
+        throw new Error(`Cannot merge schemas: conflicting types '${first.type}' and '${second.type}', ${JSON.stringify(first)} and ${JSON.stringify(second)}`);
+    }
+};

package/esm/parse/v3-2/_merge-all-of/cross-product.d.ts

@@ -0,0 +1,2 @@
+import type { SchemaOrReference } from './types.js';
+export declare const crossProduct: (a: SchemaOrReference[], b: SchemaOrReference[]) => [SchemaOrReference, SchemaOrReference][];

package/esm/parse/v3-2/_merge-all-of/cross-product.js

@@ -0,0 +1,3 @@
+export const crossProduct = (a, b) => {
+    return a.reduce((acc, x) => [...acc, ...b.map((y) => [x, y])], []);
+};

package/esm/parse/v3-2/_merge-all-of/decompose-intersection.d.ts

@@ -0,0 +1,6 @@
+import type { OpenAPIV3 } from 'openapi-types';
+type DecomposeIntersectionArgs = {
+    schema: OpenAPIV3.SchemaObject;
+};
+export declare const decomposeIntersection: ({ schema }: DecomposeIntersectionArgs) => (OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject)[];
+export {};

package/esm/parse/v3-2/_merge-all-of/decompose-intersection.js

@@ -0,0 +1,27 @@
+// Convert a schema object into an array of schemas that can be merged iteratively into a new schema
+export const decomposeIntersection = ({ schema }) => {
+    if (!schema.allOf) {
+        return [schema];
+    }
+    let location = 'before';
+    const output = {
+        before: [],
+        inside: [],
+        after: []
+    };
+    for (const [key, value] of Object.entries(schema)) {
+        if (key === 'allOf') {
+            // do not decompose wrapper for unions (oneOf, anyOf)
+            output.inside = value;
+            location = 'after';
+        }
+        else {
+            output[location].push([key, value]);
+        }
+    }
+    return [
+        output.before.length > 0 ? Object.fromEntries(output.before) : undefined,
+        ...output.inside,
+        output.after.length > 0 ? Object.fromEntries(output.after) : undefined
+    ].filter(item => item !== undefined);
+};

package/esm/parse/v3-2/_merge-all-of/decompose-union.d.ts

@@ -0,0 +1,12 @@
+import type { SchemaObject, ReferenceObject } from './types.js';
+type DecomposeUnionArgs = {
+    schema: SchemaObject;
+    groupType: 'oneOf' | 'anyOf';
+};
+type DecomposeUnionReturn = {
+    beforeExcluded: SchemaObject;
+    decomposed: (SchemaObject | ReferenceObject)[];
+    afterExcluded: SchemaObject;
+};
+export declare const decomposeUnion: ({ schema, groupType }: DecomposeUnionArgs) => DecomposeUnionReturn;
+export {};