@skmtc/core 0.0.599 → 0.0.600

package/script/oas/_helpers/parseNullable.js

@@ -0,0 +1,43 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNullable = void 0;
+const v = __importStar(require("valibot"));
+const parseNullable = ({ value, context }) => {
+    const { nullable, ...rest } = value;
+    const parsedNullable = context.provisionalParse({
+        key: 'nullable',
+        value: nullable,
+        parent: value,
+        schema: v.optional(v.boolean()),
+        toMessage: (input) => `Invalid nullable: ${input}`,
+        type: 'INVALID_NULLABLE'
+    });
+    return {
+        nullable: parsedNullable,
+        value: rest
+    };
+};
+exports.parseNullable = parseNullable;

package/script/oas/_merge-all-of/check-array-item-type-conflicts.d.ts

@@ -0,0 +1,3 @@
+import type { OpenAPIV3 } from 'openapi-types';
+export declare const checkArrayItemTypeConflicts: (a: OpenAPIV3.SchemaObject, b: OpenAPIV3.SchemaObject) => void;
+//# sourceMappingURL=check-array-item-type-conflicts.d.ts.map

package/script/oas/_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/oas/_merge-all-of/check-array-item-type-conflicts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAE9C,eAAO,MAAM,2BAA2B,MACnC,SAAS,CAAC,YAAY,KACtB,SAAS,CAAC,YAAY,KACxB,IAUF,CAAA"}

package/script/oas/_merge-all-of/check-array-item-type-conflicts.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkArrayItemTypeConflicts = void 0;
+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}'`);
+        }
+    }
+};
+exports.checkArrayItemTypeConflicts = checkArrayItemTypeConflicts;

package/script/oas/_merge-all-of/check-at-least-one-type-match.d.ts

@@ -0,0 +1,5 @@
+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 {};
+//# sourceMappingURL=check-at-least-one-type-match.d.ts.map

package/script/oas/_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/oas/_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,UAC5B,YAAY,UACX,YAAY,QACd,UAAU,KACf,OAMF,CAAA"}

package/script/oas/_merge-all-of/check-at-least-one-type-match.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAtLeastOneTypeMatch = void 0;
+const checkAtLeastOneTypeMatch = (first, second, type) => {
+    return ((first.type === type && second.type === type) ||
+        (first.type === type && !second.type) ||
+        (!first.type && second.type === type));
+};
+exports.checkAtLeastOneTypeMatch = checkAtLeastOneTypeMatch;

package/script/oas/_merge-all-of/check-enum-conflicts.d.ts

@@ -0,0 +1,3 @@
+import type { OpenAPIV3 } from 'openapi-types';
+export declare const checkEnumConflicts: (first: OpenAPIV3.SchemaObject, second: OpenAPIV3.SchemaObject) => void;
+//# sourceMappingURL=check-enum-conflicts.d.ts.map

package/script/oas/_merge-all-of/check-enum-conflicts.d.ts.map

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

package/script/oas/_merge-all-of/check-enum-conflicts.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkEnumConflicts = void 0;
+const is_equal_js_1 = require("./is-equal.js");
+const checkEnumConflicts = (first, second) => {
+    if (first.enum && second.enum) {
+        const intersection = first.enum.filter(value => {
+            return second.enum.some(bValue => (0, is_equal_js_1.isEqual)(value, bValue));
+        });
+        if (intersection.length === 0) {
+            throw new Error('Cannot merge schemas: enum values have no intersection');
+        }
+    }
+};
+exports.checkEnumConflicts = checkEnumConflicts;

package/script/oas/_merge-all-of/check-format-conflicts.d.ts

@@ -0,0 +1,3 @@
+import type { OpenAPIV3 } from 'openapi-types';
+export declare const checkFormatConflicts: (a: OpenAPIV3.SchemaObject, b: OpenAPIV3.SchemaObject) => void;
+//# sourceMappingURL=check-format-conflicts.d.ts.map

package/script/oas/_merge-all-of/check-format-conflicts.d.ts.map

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

package/script/oas/_merge-all-of/check-format-conflicts.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkFormatConflicts = void 0;
+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}'`);
+    }
+};
+exports.checkFormatConflicts = checkFormatConflicts;

package/script/oas/_merge-all-of/check-number-constraints-conflicts.d.ts

@@ -0,0 +1,3 @@
+import type { OpenAPIV3 } from 'openapi-types';
+export declare const checkNumberConstraintsConflicts: (a: OpenAPIV3.SchemaObject, b: OpenAPIV3.SchemaObject) => void;
+//# sourceMappingURL=check-number-constraints-conflicts.d.ts.map

package/script/oas/_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/oas/_merge-all-of/check-number-constraints-conflicts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAE9C,eAAO,MAAM,+BAA+B,MACvC,SAAS,CAAC,YAAY,KACtB,SAAS,CAAC,YAAY,KACxB,IAYF,CAAA"}

package/script/oas/_merge-all-of/check-number-constraints-conflicts.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkNumberConstraintsConflicts = void 0;
+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}]`);
+        }
+    }
+};
+exports.checkNumberConstraintsConflicts = checkNumberConstraintsConflicts;

package/script/oas/_merge-all-of/check-read-only-write-only-conflicts.d.ts

@@ -0,0 +1,3 @@
+import type { OpenAPIV3 } from 'openapi-types';
+export declare const checkReadOnlyWriteOnlyConflicts: (a: OpenAPIV3.SchemaObject, b: OpenAPIV3.SchemaObject) => void;
+//# sourceMappingURL=check-read-only-write-only-conflicts.d.ts.map

package/script/oas/_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/oas/_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,MACvC,SAAS,CAAC,YAAY,KACtB,SAAS,CAAC,YAAY,KACxB,IAIF,CAAA"}

package/script/oas/_merge-all-of/check-read-only-write-only-conflicts.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkReadOnlyWriteOnlyConflicts = void 0;
+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');
+    }
+};
+exports.checkReadOnlyWriteOnlyConflicts = checkReadOnlyWriteOnlyConflicts;

package/script/oas/_merge-all-of/check-type-conflicts.d.ts

@@ -0,0 +1,3 @@
+import type { OpenAPIV3 } from 'openapi-types';
+export declare const checkTypeConflicts: (first: OpenAPIV3.SchemaObject, second: OpenAPIV3.SchemaObject) => void;
+//# sourceMappingURL=check-type-conflicts.d.ts.map

package/script/oas/_merge-all-of/check-type-conflicts.d.ts.map

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

package/script/oas/_merge-all-of/check-type-conflicts.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkTypeConflicts = void 0;
+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)}`);
+    }
+};
+exports.checkTypeConflicts = checkTypeConflicts;

package/script/oas/_merge-all-of/cross-product.d.ts

@@ -0,0 +1,3 @@
+import type { SchemaOrReference } from './types.js';
+export declare const crossProduct: (a: SchemaOrReference[], b: SchemaOrReference[]) => [SchemaOrReference, SchemaOrReference][];
+//# sourceMappingURL=cross-product.d.ts.map

package/script/oas/_merge-all-of/cross-product.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cross-product.d.ts","sourceRoot":"","sources":["../../../src/oas/_merge-all-of/cross-product.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEnD,eAAO,MAAM,YAAY,MAAO,iBAAiB,EAAE,KAAK,iBAAiB,EAAE,6CAK1E,CAAA"}

package/script/oas/_merge-all-of/cross-product.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crossProduct = void 0;
+const crossProduct = (a, b) => {
+    return a.reduce((acc, x) => [...acc, ...b.map((y) => [x, y])], []);
+};
+exports.crossProduct = crossProduct;

package/script/oas/_merge-all-of/decompose-intersection.d.ts

@@ -0,0 +1,7 @@
+import type { OpenAPIV3 } from 'openapi-types';
+type DecomposeIntersectionArgs = {
+    schema: OpenAPIV3.SchemaObject;
+};
+export declare const decomposeIntersection: ({ schema }: DecomposeIntersectionArgs) => (OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject)[];
+export {};
+//# sourceMappingURL=decompose-intersection.d.ts.map

package/script/oas/_merge-all-of/decompose-intersection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decompose-intersection.d.ts","sourceRoot":"","sources":["../../../src/oas/_merge-all-of/decompose-intersection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAQ9C,KAAK,yBAAyB,GAAG;IAC/B,MAAM,EAAE,SAAS,CAAC,YAAY,CAAA;CAC/B,CAAA;AAGD,eAAO,MAAM,qBAAqB,eAE/B,yBAAyB,KAAG,CAAC,SAAS,CAAC,YAAY,GAAG,SAAS,CAAC,eAAe,CAAC,EA4BlF,CAAA"}

package/script/oas/_merge-all-of/decompose-intersection.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decomposeIntersection = void 0;
+// Convert a schema object into an array of schemas that can be merged iteratively into a new schema
+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);
+};
+exports.decomposeIntersection = decomposeIntersection;

package/script/oas/_merge-all-of/decompose-union.d.ts

@@ -0,0 +1,13 @@
+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 {};
+//# sourceMappingURL=decompose-union.d.ts.map

package/script/oas/_merge-all-of/decompose-union.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decompose-union.d.ts","sourceRoot":"","sources":["../../../src/oas/_merge-all-of/decompose-union.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAQ/D,KAAK,kBAAkB,GAAG;IACxB,MAAM,EAAE,YAAY,CAAA;IACpB,SAAS,EAAE,OAAO,GAAG,OAAO,CAAA;CAC7B,CAAA;AAED,KAAK,oBAAoB,GAAG;IAC1B,cAAc,EAAE,YAAY,CAAA;IAC5B,UAAU,EAAE,CAAC,YAAY,GAAG,eAAe,CAAC,EAAE,CAAA;IAC9C,aAAa,EAAE,YAAY,CAAA;CAC5B,CAAA;AAGD,eAAO,MAAM,cAAc,0BAA2B,kBAAkB,KAAG,oBA6C1E,CAAA"}

package/script/oas/_merge-all-of/decompose-union.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decomposeUnion = void 0;
+// Convert a schema object into an array of schemas that can be merged iteratively into a new schema
+const decomposeUnion = ({ schema, groupType }) => {
+    if (!schema[groupType]) {
+        console.log('NO GROUP TYPE', JSON.stringify(schema, null, 2));
+        return {
+            beforeExcluded: {},
+            decomposed: [schema],
+            afterExcluded: {}
+        };
+    }
+    let location = 'before';
+    const output = {
+        before: [],
+        inside: [],
+        after: []
+    };
+    for (const [key, value] of Object.entries(schema)) {
+        if (key === groupType) {
+            // do not decompose wrapper for unions (oneOf, anyOf)
+            output.inside = [{ [groupType]: value }];
+            location = 'after';
+        }
+        else {
+            output[location].push([key, value]);
+        }
+    }
+    const { retained: before, excluded: beforeExcluded } = exclude(output.before);
+    const { retained: after, excluded: afterExcluded } = exclude(output.after);
+    const decomposed = [
+        before.length > 0 ? Object.fromEntries(before) : undefined,
+        ...output.inside,
+        after.length > 0 ? Object.fromEntries(after) : undefined
+    ].filter(item => item !== undefined);
+    const result = {
+        beforeExcluded: Object.fromEntries(beforeExcluded),
+        decomposed,
+        afterExcluded: Object.fromEntries(afterExcluded)
+    };
+    return result;
+};
+exports.decomposeUnion = decomposeUnion;
+const excludedProperties = ['discriminator', 'default'];
+const exclude = (entries) => {
+    return entries.reduce((acc, [key, value]) => {
+        if (excludedProperties.includes(key)) {
+            acc.excluded.push([key, value]);
+        }
+        else {
+            acc.retained.push([key, value]);
+        }
+        return acc;
+    }, { retained: [], excluded: [] });
+};

package/script/oas/_merge-all-of/generic-merge.d.ts

@@ -0,0 +1,4 @@
+import type { SchemaObject, GetRefFn } from './types.js';
+import type * as v from 'valibot';
+export declare const genericMerge: <T>(first: SchemaObject, second: SchemaObject, getRef: GetRefFn, typeCheck?: v.GenericSchema<T>) => SchemaObject;
+//# sourceMappingURL=generic-merge.d.ts.map

package/script/oas/_merge-all-of/generic-merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generic-merge.d.ts","sourceRoot":"","sources":["../../../src/oas/_merge-all-of/generic-merge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAIxD,OAAO,KAAK,KAAK,CAAC,MAAM,SAAS,CAAA;AACjC,eAAO,MAAM,YAAY,GAAI,CAAC,SACrB,YAAY,UACX,YAAY,UACZ,QAAQ,cACJ,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,KAC7B,YAQF,CAAA"}

package/script/oas/_merge-all-of/generic-merge.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genericMerge = void 0;
+const merge_enum_values_js_1 = require("./merge-enum-values.js");
+const merge_properties_js_1 = require("./merge-properties.js");
+const merge_required_js_1 = require("./merge-required.js");
+const genericMerge = (first, second, getRef, typeCheck) => {
+    return {
+        ...first,
+        ...second,
+        ...(0, merge_properties_js_1.mergeProperties)(first, second, getRef),
+        ...(0, merge_required_js_1.mergeRequired)(first, second),
+        ...(0, merge_enum_values_js_1.mergeEnumValues)(first, second, typeCheck)
+    };
+};
+exports.genericMerge = genericMerge;

package/script/oas/_merge-all-of/is-equal.d.ts

@@ -0,0 +1,2 @@
+export declare const isEqual: (first: unknown, second: unknown) => boolean;
+//# sourceMappingURL=is-equal.d.ts.map

package/script/oas/_merge-all-of/is-equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-equal.d.ts","sourceRoot":"","sources":["../../../src/oas/_merge-all-of/is-equal.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,UAAW,OAAO,UAAU,OAAO,KAAG,OAuBzD,CAAA"}

package/script/oas/_merge-all-of/is-equal.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEqual = void 0;
+const isEqual = (first, second) => {
+    if (Array.isArray(first) && Array.isArray(second)) {
+        if (first.length !== second.length)
+            return false;
+        return first.every((value, index) => (0, exports.isEqual)(value, second[index]));
+    }
+    if (typeof first === 'object' &&
+        typeof second === 'object' &&
+        first !== null &&
+        second !== null) {
+        const aKeys = Object.keys(first);
+        const bKeys = Object.keys(second);
+        if (aKeys.length !== bKeys.length)
+            return false;
+        return aKeys.every(key => bKeys.includes(key) &&
+            (0, exports.isEqual)(first[key], second[key]));
+    }
+    return first === second;
+};
+exports.isEqual = isEqual;

package/script/oas/_merge-all-of/merge-array-constraints.d.ts

@@ -0,0 +1,3 @@
+import type { ArraySchemaObject, GetRefFn, SchemaObject } from './types.js';
+export declare function mergeArrayConstraints(first: ArraySchemaObject | SchemaObject, second: ArraySchemaObject | SchemaObject, getRef: GetRefFn): ArraySchemaObject;
+//# sourceMappingURL=merge-array-constraints.d.ts.map

package/script/oas/_merge-all-of/merge-array-constraints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-array-constraints.d.ts","sourceRoot":"","sources":["../../../src/oas/_merge-all-of/merge-array-constraints.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,QAAQ,EAAE,YAAY,EAAqB,MAAM,YAAY,CAAA;AAI9F,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,iBAAiB,GAAG,YAAY,EACvC,MAAM,EAAE,iBAAiB,GAAG,YAAY,EACxC,MAAM,EAAE,QAAQ,GACf,iBAAiB,CAiCnB"}

package/script/oas/_merge-all-of/merge-array-constraints.js

@@ -0,0 +1,70 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeArrayConstraints = mergeArrayConstraints;
+const merge_js_1 = require("./merge.js");
+const generic_merge_js_1 = require("./generic-merge.js");
+const v = __importStar(require("valibot"));
+const check_type_conflicts_js_1 = require("./check-type-conflicts.js");
+function mergeArrayConstraints(first, second, getRef) {
+    (0, check_type_conflicts_js_1.checkTypeConflicts)(first, second);
+    if (!('items' in first) && !('items' in second)) {
+        throw new Error('Cannot merge array constraints: no items found');
+    }
+    const result = {
+        ...(0, generic_merge_js_1.genericMerge)(first, second, getRef, v.array(v.any())),
+        type: 'array',
+        items: mergeItems(first, second, getRef)
+    };
+    // Merge minItems
+    if (first.minItems !== undefined || second.minItems !== undefined) {
+        const minA = first.minItems ?? 0;
+        const minB = second.minItems ?? 0;
+        result.minItems = Math.max(minA, minB);
+    }
+    // Merge maxItems
+    if (first.maxItems !== undefined || second.maxItems !== undefined) {
+        const maxA = first.maxItems ?? Infinity;
+        const maxB = second.maxItems ?? Infinity;
+        result.maxItems = Math.min(maxA, maxB);
+    }
+    // Merge uniqueItems
+    if (first.uniqueItems || second.uniqueItems) {
+        result.uniqueItems = true;
+    }
+    return result;
+}
+const mergeItems = (first, second, getRef) => {
+    if ('items' in first && 'items' in second && first.items && second.items) {
+        return (0, merge_js_1.mergeSchemasOrRefs)(first.items, second.items, getRef);
+    }
+    if ('items' in first && first.items) {
+        return first.items;
+    }
+    if ('items' in second && second.items) {
+        return second.items;
+    }
+    throw new Error('Cannot merge array constraints: no items found');
+};

package/script/oas/_merge-all-of/merge-boolean-constraints.d.ts

@@ -0,0 +1,4 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { GetRefFn } from './types.js';
+export declare function mergeBooleanConstraints(first: OpenAPIV3.SchemaObject, second: OpenAPIV3.SchemaObject, getRef: GetRefFn): OpenAPIV3.SchemaObject;
+//# sourceMappingURL=merge-boolean-constraints.d.ts.map

package/script/oas/_merge-all-of/merge-boolean-constraints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-boolean-constraints.d.ts","sourceRoot":"","sources":["../../../src/oas/_merge-all-of/merge-boolean-constraints.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAE9C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAG1C,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,SAAS,CAAC,YAAY,EAC7B,MAAM,EAAE,SAAS,CAAC,YAAY,EAC9B,MAAM,EAAE,QAAQ,GACf,SAAS,CAAC,YAAY,CAIxB"}

package/script/oas/_merge-all-of/merge-boolean-constraints.js

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeBooleanConstraints = mergeBooleanConstraints;
+const generic_merge_js_1 = require("./generic-merge.js");
+const v = __importStar(require("valibot"));
+const check_type_conflicts_js_1 = require("./check-type-conflicts.js");
+function mergeBooleanConstraints(first, second, getRef) {
+    (0, check_type_conflicts_js_1.checkTypeConflicts)(first, second);
+    return (0, generic_merge_js_1.genericMerge)(first, second, getRef, v.boolean());
+}

package/script/oas/_merge-all-of/merge-enum-values.d.ts

@@ -0,0 +1,4 @@
+import type { SchemaObject } from './types.js';
+import * as v from 'valibot';
+export declare function mergeEnumValues<T>(first: SchemaObject, second: SchemaObject, typeCheck?: v.GenericSchema<T>): Pick<SchemaObject, 'enum'>;
+//# sourceMappingURL=merge-enum-values.d.ts.map

package/script/oas/_merge-all-of/merge-enum-values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-enum-values.d.ts","sourceRoot":"","sources":["../../../src/oas/_merge-all-of/merge-enum-values.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAC9C,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAM5B,wBAAgB,eAAe,CAAC,CAAC,EAC/B,KAAK,EAAE,YAAY,EACnB,MAAM,EAAE,YAAY,EACpB,SAAS,CAAC,EAAE,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,GAC7B,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,CA+B5B"}

package/script/oas/_merge-all-of/merge-enum-values.js

@@ -0,0 +1,58 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeEnumValues = mergeEnumValues;
+const is_equal_js_1 = require("./is-equal.js");
+const v = __importStar(require("valibot"));
+const containsEnum = (schema) => {
+    return Array.isArray(schema.enum);
+};
+function mergeEnumValues(first, second, typeCheck) {
+    if (!containsEnum(first) && !containsEnum(second)) {
+        return {};
+    }
+    if (!containsEnum(first) && containsEnum(second)) {
+        return {
+            enum: second.enum
+        };
+    }
+    if (containsEnum(first) && !containsEnum(second)) {
+        return {
+            enum: first.enum
+        };
+    }
+    // Find intersection of enum values
+    const intersection = first
+        .enum.filter(value => second.enum.some(bValue => (0, is_equal_js_1.isEqual)(value, bValue)))
+        .map(value => (typeCheck ? v.parse(typeCheck, value) : value));
+    // If intersection is empty, throw error
+    if (intersection.length === 0) {
+        throw new Error('Merged schema has empty enum array');
+    }
+    // Return merged schema with intersection of enum values
+    return {
+        enum: intersection
+    };
+}

package/script/oas/_merge-all-of/merge-integer-constraints.d.ts

@@ -0,0 +1,4 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { GetRefFn } from './types.js';
+export declare function mergeIntegerConstraints(first: OpenAPIV3.SchemaObject, second: OpenAPIV3.SchemaObject, getRef: GetRefFn): OpenAPIV3.SchemaObject;
+//# sourceMappingURL=merge-integer-constraints.d.ts.map

package/script/oas/_merge-all-of/merge-integer-constraints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-integer-constraints.d.ts","sourceRoot":"","sources":["../../../src/oas/_merge-all-of/merge-integer-constraints.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAG9C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAG1C,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,SAAS,CAAC,YAAY,EAC7B,MAAM,EAAE,SAAS,CAAC,YAAY,EAC9B,MAAM,EAAE,QAAQ,GACf,SAAS,CAAC,YAAY,CA2CxB"}