@x0k/json-schema-merge 1.0.0

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2025 Roman Krasilnikov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,181 @@
+# JSON Schema merge
+
+A minimal JSON Schema merging library.
+
+```shell
+npm i @x0k/json-schema-merge
+```
+
+**Goals**
+
+- Fast and correct merging of JSON Schemas Draft-07
+- Shallow merging of the `allOf` keyword
+
+**Non-goals**
+
+- Support for drafts other than Draft-07
+- Deep merging of the `allOf` keyword (possible, but not optimal)
+- Handling invalid or incorrect JSON Schemas (the merge result is undefined)
+- Resolving `$ref` references (see [json-schema-ref-parser](https://github.com/APIDevTools/json-schema-ref-parser))
+
+## Usage
+
+```ts
+import {
+  createDeduplicator,
+  createIntersector,
+} from "@x0k/json-schema-merge/lib/array";
+import {
+  createMerger,
+  createComparator,
+  createShallowAllOfMerge,
+} from "@x0k/json-schema-merge";
+
+const { compareSchemaDefinitions, compareSchemaValues } = createComparator();
+
+const { mergeArrayOfSchemaDefinitions } = createMerger({
+  intersectJson: createIntersector(compareSchemaValues),
+  deduplicateJsonSchemaDef: createDeduplicator(compareSchemaDefinitions),
+});
+
+const shallowAllOfMerge = createShallowAllOfMerge(
+  mergeArrayOfSchemaDefinitions
+);
+
+const merged = shallowAllOfMerge({
+  /* your schema with `allOf` keyword */
+});
+```
+
+### Options
+
+```ts
+/**
+ * Function type for removing duplicates from an array.
+ * Should return a new array with unique elements only.
+ */
+export type Deduplicator<T> = (data: T[]) => T[];
+
+/**
+ * Function type for intersecting two arrays of the same type.
+ */
+export type Intersector<T> = (a: T[], b: T[]) => T[];
+
+/**
+ * A merger function combines two values for a specific JSON Schema keyword.
+ */
+export type Merger<T> = (a: T, b: T) => T;
+
+/**
+ * An assigner function operates at the schema-object level.
+ * It receives the partially merged `target` and the original
+ * `left` and `right` schemas.
+ *
+ * In most cases, it modifies and returns the `target` object,
+ * but it may also return a completely new schema object if needed.
+ *
+ * Assigners are used for keywords that cannot be merged by simple
+ * value-level functions, often because they interact with other
+ * keywords or require holistic decisions.
+ */
+export type Assigner<R extends {}> = (target: R, l: R, r: R) => R;
+
+/**
+ * A validation function that ensures consistency between two schema keywords.
+ */
+export type Check<K extends SchemaKey> = (
+  target: Required<Pick<JSONSchema7, K>>
+) => boolean;
+
+export type CheckEntry<A extends SchemaKey, B extends SchemaKey> = readonly [
+  A,
+  B,
+  Check<A | B>,
+];
+
+export interface MergeOptions {
+  /**
+   * Custom function to test whether a regular expression `subExpr`
+   * is considered a subset of another `superExpr`.
+   * @default Object.is
+   */
+  isSubRegExp?: (subExpr: string, superExpr: string) => boolean;
+
+  /**
+   * Merger function for combining regular expression patterns
+   * @default simplePatternsMerger
+   */
+  mergePatterns?: Merger<string>;
+
+  /**
+   * Intersector function for merging JSON values (enum keyword)
+   * @default intersection
+   */
+  intersectJson?: Intersector<JSONSchema7Type>;
+
+  /**
+   * Deduplication strategy for JSON Schema definitions.
+   * @default identity
+   */
+  deduplicateJsonSchemaDef?: Deduplicator<JSONSchema7Definition>;
+
+  /**
+   * Fallback merger applied when no keyword-specific merger is defined.
+   * @default identity
+   */
+  defaultMerger?: Merger<any>;
+
+  /**
+   * A mapping of schema keywords to merger functions.
+   *
+   * - A merger operates on **values of a single keyword** (`a`, `b` → merged value).
+   * - When provided, a custom merger **overrides the default merger** for that keyword.
+   */
+  mergers?: Partial<{
+    [K in SchemaKey]: Merger<Exclude<JSONSchema7[K], undefined>>;
+  }>;
+
+  /**
+   * A collection of keyword groups with associated assigner functions.
+   *
+   * - An assigner operates at the **schema-object level** (`target`, `left`, `right`).
+   * - Custom assigners are **appended** to the default assigners,
+   *   but can also **replace behavior** for specific keywords if they overlap.
+   */
+  assigners?: Iterable<[SchemaKey[], Assigner<JSONSchema7>]>;
+
+  /**
+   * Consistency checks to validate relationships between
+   * pairs of schema keywords (e.g. `minimum` ≤ `maximum`).
+   *
+   * - A check ensures that two related keywords do not conflict.
+   * - Providing this option **replaces the default checks** completely.
+   *
+   * @default DEFAULT_CHECKS
+   */
+  checks?: Iterable<CheckEntry<SchemaKey, SchemaKey>>;
+}
+```
+
+## Compatibility
+
+This library was originally developed as part of the [svelte-jsonschema-form](https://github.com/x0k/svelte-jsonschema-form) project to replace [json-schema-merge-allof](https://github.com/mokkabonna/json-schema-merge-allof) and [json-schema-compare](https://github.com/mokkabonna/json-schema-compare).
+
+It can be used as a drop-in alternative with the following differences:
+
+### Compared to `json-schema-compare`
+
+- See the usage of the `DOES_NOT_MATCH` constant in the [comparison test](./src/lib/json-schema/compare/compare.test.ts)
+
+### Compared to `json-schema-merge-allof`
+
+- Uses a different algorithm for sorting JSON values — order in array-like structures may differ
+- More precise merging of the `properties`, `patternProperties`, and `additionalProperties` keywords
+- Support for merging `number` and `integer` types
+- Support for merging `if`, `then` and `else` keywords
+- Fixed merging of regular expressions (see [comparison test](./src/lib/json-schema/merge/patterns.test.ts))
+- Built-in schema consistency checks (e.g. `minimum` ≤ `maximum`)
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./lib/json-schema/index.ts";

package/dist/index.js

@@ -0,0 +1 @@
+export * from "./lib/json-schema/index.js";

package/dist/lib/array.d.ts

@@ -0,0 +1,19 @@
+import type { Comparator } from "./ord.ts";
+export declare function union<T>(larger: T[], smaller: T[]): T[];
+export declare function intersection<T>(a: T[], b: T[]): T[];
+export declare function isArrayEmpty<T>(arr: T[]): arr is [];
+export declare function createArrayComparator<T>(compare: (a: T, b: T) => number): (a: T[], b: T[]) => number;
+/**
+ * Function type for removing duplicates from an array.
+ */
+export type Deduplicator<T> = (data: T[]) => T[];
+export interface DeduplicatorOptions {
+    /** @default 12 */
+    threshold?: number;
+}
+export declare function createDeduplicator<T>(compare: Comparator<T>, { threshold }?: DeduplicatorOptions): Deduplicator<T>;
+/**
+ * Function type for intersecting two arrays of the same type.
+ */
+export type Intersector<T> = (a: T[], b: T[]) => T[];
+export declare function createIntersector<T>(compare: Comparator<T>): Intersector<T>;

package/dist/lib/array.js

@@ -0,0 +1,133 @@
+export function union(larger, smaller) {
+    const ll = larger.length;
+    if (ll === 0) {
+        return smaller;
+    }
+    let sl = smaller.length;
+    if (sl === 0) {
+        return larger;
+    }
+    if (ll < sl) {
+        const tmp = larger;
+        larger = smaller;
+        smaller = tmp;
+        sl = ll;
+    }
+    const data = new Set(larger);
+    for (let i = 0; i < sl; i++) {
+        data.add(smaller[i]);
+    }
+    return Array.from(data);
+}
+export function intersection(a, b) {
+    const result = [];
+    if (a.length === 0 || b.length === 0) {
+        return result;
+    }
+    if (a.length > b.length) {
+        const tmp = a;
+        a = b;
+        b = tmp;
+    }
+    const setB = new Set(b);
+    for (let i = 0; i < a.length && setB.size > 0; i++) {
+        const val = a[i];
+        if (setB.delete(val)) {
+            result.push(val);
+        }
+    }
+    return result;
+}
+export function isArrayEmpty(arr) {
+    return arr.length === 0;
+}
+export function createArrayComparator(compare) {
+    return (a, b) => {
+        const d = a.length - b.length;
+        if (d !== 0) {
+            return d;
+        }
+        for (let i = 0; i < a.length; i++) {
+            if (a[i] !== b[i]) {
+                const d = compare(a[i], b[i]);
+                if (d !== 0) {
+                    return d;
+                }
+            }
+        }
+        return 0;
+    };
+}
+export function createDeduplicator(compare, { threshold = 12 } = {}) {
+    return (arr) => {
+        const al = arr.length;
+        if (al === 0) {
+            return arr;
+        }
+        if (al <= threshold) {
+            const result = [];
+            let rl = 0;
+            outer: for (let i = 0; i < al; i++) {
+                const item = arr[i];
+                for (let j = 0; j < rl; j++) {
+                    if (compare(item, result[j]) === 0) {
+                        continue outer;
+                    }
+                }
+                rl = result.push(item);
+            }
+            return result;
+        }
+        const sorted = arr.slice().sort(compare);
+        let wIndex = 0;
+        for (let rIndex = 1; rIndex < al; rIndex++) {
+            if (compare(sorted[wIndex], sorted[rIndex]) !== 0) {
+                if (++wIndex !== rIndex) {
+                    sorted[wIndex] = sorted[rIndex];
+                }
+            }
+        }
+        sorted.length = wIndex + 1;
+        return sorted;
+    };
+}
+export function createIntersector(compare) {
+    return (a, b) => {
+        const result = [];
+        let al = a.length;
+        let bl = b.length;
+        if (al === 0 || bl === 0) {
+            return result;
+        }
+        if (al > bl) {
+            const tmpArr = a;
+            a = b;
+            b = tmpArr;
+            const tmpL = al;
+            al = bl;
+            bl = tmpL;
+        }
+        const aSorted = [...a].sort(compare);
+        const bSorted = [...b].sort(compare);
+        let i = 0, j = 0;
+        while (i < al && j < bl) {
+            const cmp = compare(aSorted[i], bSorted[j]);
+            if (cmp === 0) {
+                // Only push if result is empty OR last pushed value is different
+                if (result.length === 0 ||
+                    compare(result[result.length - 1], aSorted[i]) !== 0) {
+                    result.push(aSorted[i]);
+                }
+                i++;
+                j++;
+            }
+            else if (cmp < 0) {
+                i++;
+            }
+            else {
+                j++;
+            }
+        }
+        return result;
+    };
+}

package/dist/lib/function.d.ts

@@ -0,0 +1 @@
+export declare function identity<T>(v: T): T;

package/dist/lib/function.js

@@ -0,0 +1,3 @@
+export function identity(v) {
+    return v;
+}

package/dist/lib/json-schema/compare/compare.d.ts

@@ -0,0 +1,9 @@
+import type { JSONSchema7Type as SchemaValue, JSONSchema7Definition } from "json-schema";
+export interface ComparatorOptions {
+    deduplicationCache?: WeakMap<any[], any[]>;
+    sortedKeysCache?: WeakMap<Record<string, any>, string[]>;
+}
+export declare function createComparator({ deduplicationCache, sortedKeysCache, }?: ComparatorOptions): {
+    compareSchemaValues: (a: SchemaValue, b: SchemaValue) => number;
+    compareSchemaDefinitions: (a: JSONSchema7Definition, b: JSONSchema7Definition) => number;
+};

package/dist/lib/json-schema/compare/compare.js

@@ -0,0 +1,205 @@
+import { ascComparator } from "../../ord.js";
+import { createArrayComparator, createDeduplicator, isArrayEmpty, } from "../../array.js";
+import { isRecordEmpty } from "../../object.js";
+import { weakMemoize } from "../../memoize.js";
+import { isAllowAnySchema, isSchemaObject } from "../json-schema.js";
+const zero = () => 0;
+const isUndefined = (v) => v === undefined;
+const isSchemaPrimitiveExceptNull = (value) => typeof value !== "object";
+const PRIMITIVE_TYPE_ORDER = {
+    boolean: 0,
+    number: 1,
+    string: 2,
+};
+function compareSchemaPrimitive(a, b) {
+    const ta = typeof a;
+    const tb = typeof b;
+    return ta === tb
+        ? ascComparator(a, b)
+        : PRIMITIVE_TYPE_ORDER[ta] - PRIMITIVE_TYPE_ORDER[tb];
+}
+function insertUniqueValues(mutableTarget, mutableSource) {
+    const tl = mutableTarget.length;
+    if (tl === 0)
+        return mutableSource;
+    const sl = mutableSource.length;
+    if (sl === 0)
+        return mutableTarget;
+    if (sl > tl) {
+        const t = mutableTarget;
+        mutableTarget = mutableSource;
+        mutableSource = t;
+    }
+    const seen = new Set(mutableTarget);
+    const l = mutableSource.length;
+    for (let i = 0; i < l; i++) {
+        const key = mutableSource[i];
+        if (!seen.has(key)) {
+            mutableTarget.push(key);
+        }
+    }
+    return mutableTarget;
+}
+function createCmpMatcher(isEmpty, compare, compareEmpty = zero) {
+    return (a, b) => {
+        if (isEmpty(a)) {
+            if (isEmpty(b)) {
+                return compareEmpty(a, b);
+            }
+            return -1;
+        }
+        if (isEmpty(b)) {
+            return 1;
+        }
+        return compare(a, b);
+    };
+}
+function createOptionalComparator(compare) {
+    return createCmpMatcher(isUndefined, compare);
+}
+function createNarrowingOptionalComparator(isEmpty, compare) {
+    return createCmpMatcher((v) => v === undefined || isEmpty(v), compare);
+}
+function createArrayOrItemComparator(compare, compareArray) {
+    return createCmpMatcher(Array.isArray, compare, compareArray);
+}
+const compareOptionalSameTypeSchemaPrimitives = createOptionalComparator(ascComparator);
+const compareNumbersWithZeroDefault = createNarrowingOptionalComparator((v) => v === 0, (a, b) => a - b);
+export function createComparator({ deduplicationCache = new WeakMap(), sortedKeysCache = new WeakMap(), } = {}) {
+    const getSortedKeys = weakMemoize(sortedKeysCache, (obj) => Object.keys(obj).sort());
+    function createRecordsComparator(compare) {
+        return (a, b) => {
+            const aKeys = getSortedKeys(a);
+            const bKeys = getSortedKeys(b);
+            const l = Math.min(aKeys.length, bKeys.length);
+            for (let i = 0; i < l; i++) {
+                const cmp = ascComparator(aKeys[i], bKeys[i]);
+                if (cmp !== 0) {
+                    return cmp;
+                }
+            }
+            if (aKeys.length !== bKeys.length) {
+                return aKeys.length - bKeys.length;
+            }
+            for (let i = 0; i < l; i++) {
+                const key = aKeys[i];
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                const cmp = compare(a[key], b[key]);
+                if (cmp !== 0) {
+                    return cmp;
+                }
+            }
+            return 0;
+        };
+    }
+    function createArrayComparatorWithDeduplication(compare) {
+        const cmp = createArrayComparator(compare);
+        const deduplicate = weakMemoize(deduplicationCache, 
+        // NOTE: Always sort output
+        createDeduplicator(compare, { threshold: 0 }));
+        return (a, b) => cmp(deduplicate(a), deduplicate(b));
+    }
+    const compareArrayOfSameTypePrimitivesWithDeduplication = createArrayComparatorWithDeduplication(ascComparator);
+    function compareSchemaDefinitions(a, b) {
+        if (isSchemaObject(a)) {
+            if (isSchemaObject(b)) {
+                const aKeys = Object.keys(a);
+                const bKeys = Object.keys(b);
+                const allKeys = insertUniqueValues(aKeys, bKeys);
+                const l = allKeys.length;
+                for (let i = 0; i < l; i++) {
+                    const key = allKeys[i];
+                    if (a[key] === b[key]) {
+                        continue;
+                    }
+                    const cmp = COMPARATORS[key] ?? compareOptionalSchemaValues;
+                    const d = cmp(a[key], b[key]);
+                    if (d !== 0) {
+                        return d;
+                    }
+                }
+                return 0;
+            }
+            return b === true && isRecordEmpty(a) ? 0 : 1;
+        }
+        if (isSchemaObject(b)) {
+            return a === true && isRecordEmpty(b) ? 0 : -1;
+        }
+        return ascComparator(a, b);
+    }
+    const compareOptionalSchemaValues = createOptionalComparator(compareSchemaValues);
+    const compareNonNullSchemaValue = createCmpMatcher(isSchemaPrimitiveExceptNull, createArrayOrItemComparator(createRecordsComparator(compareOptionalSchemaValues), createArrayComparator(compareSchemaValues)), compareSchemaPrimitive);
+    function compareSchemaValues(a, b) {
+        if (a === null) {
+            return -1;
+        }
+        if (b === null) {
+            return 1;
+        }
+        return compareNonNullSchemaValue(a, b);
+    }
+    const compareOptionalSchemaDefinitions = createOptionalComparator(compareSchemaDefinitions);
+    const compareRecordOfOptionalSchemasWithEmptyRecordDefault = createNarrowingOptionalComparator(isRecordEmpty, createRecordsComparator(compareOptionalSchemaDefinitions));
+    const compareOptionalArrayOfSchemasWithDeduplication = createOptionalComparator(createArrayComparatorWithDeduplication(compareSchemaDefinitions));
+    const compareSchemaDefinitionsWithEmptyDefinitionDefault = createNarrowingOptionalComparator(isAllowAnySchema, compareSchemaDefinitions);
+    const COMPARATORS = {
+        $id: compareOptionalSameTypeSchemaPrimitives,
+        $comment: compareOptionalSameTypeSchemaPrimitives,
+        $defs: compareRecordOfOptionalSchemasWithEmptyRecordDefault,
+        $ref: compareOptionalSameTypeSchemaPrimitives,
+        $schema: compareOptionalSameTypeSchemaPrimitives,
+        const: compareOptionalSchemaValues,
+        contains: compareOptionalSchemaDefinitions,
+        contentEncoding: compareOptionalSameTypeSchemaPrimitives,
+        contentMediaType: compareOptionalSameTypeSchemaPrimitives,
+        default: compareOptionalSchemaValues,
+        definitions: compareRecordOfOptionalSchemasWithEmptyRecordDefault,
+        description: compareOptionalSameTypeSchemaPrimitives,
+        else: compareOptionalSchemaDefinitions,
+        examples: compareOptionalSchemaValues,
+        exclusiveMaximum: compareOptionalSameTypeSchemaPrimitives,
+        exclusiveMinimum: compareOptionalSameTypeSchemaPrimitives,
+        format: compareOptionalSameTypeSchemaPrimitives,
+        if: compareOptionalSchemaDefinitions,
+        maximum: compareOptionalSameTypeSchemaPrimitives,
+        maxItems: compareOptionalSameTypeSchemaPrimitives,
+        maxLength: compareOptionalSameTypeSchemaPrimitives,
+        maxProperties: compareOptionalSameTypeSchemaPrimitives,
+        minimum: compareOptionalSameTypeSchemaPrimitives,
+        multipleOf: compareOptionalSameTypeSchemaPrimitives,
+        not: compareOptionalSchemaDefinitions,
+        pattern: compareOptionalSameTypeSchemaPrimitives,
+        propertyNames: compareOptionalSchemaDefinitions,
+        readOnly: compareOptionalSameTypeSchemaPrimitives,
+        then: compareOptionalSchemaDefinitions,
+        title: compareOptionalSameTypeSchemaPrimitives,
+        writeOnly: compareOptionalSameTypeSchemaPrimitives,
+        uniqueItems: createNarrowingOptionalComparator((v) => v === false, zero),
+        minLength: compareNumbersWithZeroDefault,
+        minItems: compareNumbersWithZeroDefault,
+        minProperties: compareNumbersWithZeroDefault,
+        required: createNarrowingOptionalComparator(isArrayEmpty, compareArrayOfSameTypePrimitivesWithDeduplication),
+        enum: createNarrowingOptionalComparator(isArrayEmpty, createArrayComparatorWithDeduplication(compareSchemaValues)),
+        type: createOptionalComparator((a, b) => {
+            const isAArr = Array.isArray(a);
+            const isBArr = Array.isArray(b);
+            if (!isAArr && !isBArr) {
+                return ascComparator(a, b);
+            }
+            return compareArrayOfSameTypePrimitivesWithDeduplication(isAArr ? a : [a], isBArr ? b : [b]);
+        }),
+        items: createNarrowingOptionalComparator((v) => !Array.isArray(v) && isAllowAnySchema(v), createArrayOrItemComparator(compareSchemaDefinitions, createArrayComparator(compareSchemaDefinitions))),
+        anyOf: compareOptionalArrayOfSchemasWithDeduplication,
+        allOf: compareOptionalArrayOfSchemasWithDeduplication,
+        oneOf: compareOptionalArrayOfSchemasWithDeduplication,
+        properties: compareRecordOfOptionalSchemasWithEmptyRecordDefault,
+        patternProperties: compareRecordOfOptionalSchemasWithEmptyRecordDefault,
+        additionalProperties: compareSchemaDefinitionsWithEmptyDefinitionDefault,
+        additionalItems: compareSchemaDefinitionsWithEmptyDefinitionDefault,
+        dependencies: createNarrowingOptionalComparator(isRecordEmpty, createRecordsComparator(createOptionalComparator(createArrayOrItemComparator(compareSchemaDefinitions, compareArrayOfSameTypePrimitivesWithDeduplication)))),
+    };
+    return {
+        compareSchemaValues,
+        compareSchemaDefinitions,
+    };
+}

package/dist/lib/json-schema/compare/index.d.ts

@@ -0,0 +1 @@
+export * from "./compare.ts";

package/dist/lib/json-schema/compare/index.js

@@ -0,0 +1 @@
+export * from "./compare.js";

package/dist/lib/json-schema/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./json-schema.ts";
+export * from "./transform.ts";
+export * from "./traverse.ts";
+export * from "./compare/index.ts";
+export * from "./merge/index.ts";

package/dist/lib/json-schema/index.js

@@ -0,0 +1,5 @@
+export * from "./json-schema.js";
+export * from "./transform.js";
+export * from "./traverse.js";
+export * from "./compare/index.js";
+export * from "./merge/index.js";

package/dist/lib/json-schema/json-schema.d.ts

@@ -0,0 +1,37 @@
+import type { JSONSchema7TypeName, JSONSchema7Definition } from "json-schema";
+export declare const JSON_SCHEMA_TYPE_NAMES: string[];
+export declare const SET_OF_JSON_SCHEMA_TYPE_NAMES: Set<string>;
+export declare function isJsonSchemaType(type: string): type is JSONSchema7TypeName;
+export declare const RECORDS_OF_SUB_SCHEMAS: ["$defs", "definitions", "properties", "patternProperties", "dependencies"];
+export declare const SET_OF_RECORDS_OF_SUB_SCHEMAS: Set<"$defs" | "properties" | "patternProperties" | "dependencies" | "definitions">;
+export type SubSchemasRecordKey = (typeof RECORDS_OF_SUB_SCHEMAS)[number];
+export declare const ARRAYS_OF_SUB_SCHEMAS: ["items", "allOf", "oneOf", "anyOf"];
+export declare const SET_OF_ARRAYS_OF_SUB_SCHEMAS: Set<"items" | "allOf" | "anyOf" | "oneOf">;
+export type SubSchemasArrayKey = (typeof ARRAYS_OF_SUB_SCHEMAS)[number];
+export declare const SUB_SCHEMAS: ["items", "additionalItems", "additionalProperties", "propertyNames", "contains", "if", "then", "else", "not"];
+export declare const SET_OF_SUB_SCHEMAS: Set<"items" | "additionalItems" | "contains" | "additionalProperties" | "propertyNames" | "if" | "then" | "else" | "not">;
+export type SubSchemaKey = (typeof SUB_SCHEMAS)[number];
+export declare const ALL_SUB_SCHEMA_KEYS: ("$defs" | "items" | "additionalItems" | "contains" | "properties" | "patternProperties" | "additionalProperties" | "dependencies" | "propertyNames" | "if" | "then" | "else" | "allOf" | "anyOf" | "oneOf" | "not" | "definitions")[];
+export type AnySubSchemaKey = (typeof ALL_SUB_SCHEMA_KEYS)[number];
+export type TransformedSchema<R, S> = Omit<S, AnySubSchemaKey> & {
+    items?: R | R[] | undefined;
+    additionalItems?: R | undefined;
+    contains?: R | undefined;
+    additionalProperties?: R | undefined;
+    propertyNames?: R | undefined;
+    if?: R | undefined;
+    then?: R | undefined;
+    else?: R | undefined;
+    not?: R | undefined;
+    $defs?: Record<string, R> | undefined;
+    properties?: Record<string, R> | undefined;
+    patternProperties?: Record<string, R> | undefined;
+    dependencies?: Record<string, R | string[]> | undefined;
+    definitions?: Record<string, R> | undefined;
+    allOf?: R[] | undefined;
+    anyOf?: R[] | undefined;
+    oneOf?: R[] | undefined;
+};
+export type TransformedSchemaDefinition<R, S> = TransformedSchema<R, S> | boolean;
+export declare function isSchemaObject<D extends JSONSchema7Definition>(schemaDef: D): schemaDef is Exclude<D, boolean>;
+export declare function isAllowAnySchema(def: JSONSchema7Definition): def is true | Record<string, never>;