json-schema-describes-subset/dist/built-in-plugins/array.d.ts

Tools for static JSON schema analysis, including functions to determine if one schema describes a subset of another or if a schema describes the empty set or to convert a schema to its disjunctive normal form (DNF).

import { type JSONSchema } from '../json-schema/index.js';
import { AtomicSchemaObject, type LogicalCombinationOfLiterals } from '../atomic-schema/index.js';
import type { ExtractionPlugin, ConjunctionSchema } from '../plugin/index.js';
export declare function createTrueArray(length: number): true[];
export declare class MinItemsAtomicSchema extends AtomicSchemaObject {
    readonly minItems: number;
    constructor(minItems: number);
    negate(): LogicalCombinationOfLiterals;
    toJSONSchema(): {
        minItems: number;
    };
}
export declare class MaxItemsAtomicSchema extends AtomicSchemaObject {
    readonly maxItems: number;
    constructor(maxItems: number);
    negate(): LogicalCombinationOfLiterals;
    toJSONSchema(): {
        maxItems: number;
    };
}
export declare class ItemsAtomicSchema extends AtomicSchemaObject {
    readonly startIndex: number;
    readonly items: JSONSchema;
    constructor(startIndex: number, items: JSONSchema);
    negate(): LogicalCombinationOfLiterals;
    toJSONSchema(): {
        prefixItems?: true[];
        items: JSONSchema;
    };
}
export declare class PrefixItemAtomicSchema extends AtomicSchemaObject {
    readonly index: number;
    readonly prefixItem: JSONSchema;
    constructor(index: number, prefixItem: JSONSchema);
    negate(): LogicalCombinationOfLiterals;
    toJSONSchema(): {
        prefixItems: [...true[], JSONSchema];
    };
}
export declare class ContainsAtomicSchema extends AtomicSchemaObject {
    readonly contains: JSONSchema;
    readonly minContains: number;
    readonly maxContains: number;
    constructor(contains: JSONSchema, minContains: number, maxContains: number);
    negate(): LogicalCombinationOfLiterals;
    toJSONSchema(): {
        contains: JSONSchema;
        minContains: number;
        maxContains?: number;
    };
}
export declare class UniqueItemsAtomicSchema extends AtomicSchemaObject {
    negate(): LogicalCombinationOfLiterals;
    toJSONSchema(): {
        uniqueItems: true;
    };
}
export declare class UnevaluatedItemsAtomicSchema extends AtomicSchemaObject {
    negate(): LogicalCombinationOfLiterals;
    toJSONSchema(): JSONSchema;
}
export declare const arrayExtraction: ExtractionPlugin;
export declare function mergeItemsSchemas(prefixItems: PrefixItemAtomicSchema[], itemsArray: ItemsAtomicSchema[]): JSONSchema[][];
export type ArrayConjunctionSchema = {
    minItems?: number;
    maxItems?: number;
    items?: JSONSchema;
    prefixItems?: JSONSchema[];
    uniqueItems?: boolean;
    allOf?: ({
        not: {
            const: unknown[];
        };
    } | {
        contains: JSONSchema;
        minContains?: number;
        maxContains?: number;
    } | {
        not: {
            uniqueItems?: boolean;
        };
    } | {
        not: {
            prefixItems?: true[];
            items?: JSONSchema;
        };
    })[];
};
export declare const arraySimplification: {
    readonly appliesToJSONSchemaType: "array";
    readonly mergeableKeywords: ["items", "prefixItems", "minItems", "maxItems", "uniqueItems"];
    readonly simplify: ({ atomicSchemasByConstructor, negatedAtomicSchemasByConstructor, schemaDescribesEmptySet, validateConst, }: import("../plugin/plugin.js").SimplificationPluginArguments) => ConjunctionSchema<ArrayConjunctionSchema>;
};