@takeshape/json-schema 11.143.2 → 11.154.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takeshape/json-schema",
-  "version": "11.143.2",
+  "version": "11.154.1",
   "description": "JSON Schema validator",
   "homepage": "https://www.takeshape.io",
   "repository": {
@@ -38,7 +38,7 @@
     "ajv-formats": "3.0.1",
     "lodash": "4.17.21",
     "minimatch": "3.1.2",
-    "@takeshape/util": "11.143.2"
+    "@takeshape/util": "11.154.1"
   },
   "devDependencies": {
     "@types/json-schema": "7.0.15",

package/dist/converters/index.d.ts

@@ -1 +0,0 @@
-export * from './schema-converter.ts';

package/dist/converters/index.js

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

package/dist/converters/schema-converter.d.ts

@@ -1,64 +0,0 @@
-import type { JSONSchema7 } from 'json-schema';
-export type SchemaConversionStats = {
-    propertiesCount: number;
-    stringLength: number;
-    enumValuesCount: number;
-};
-export type SchemaConversionResult = {
-    schema: JSONSchema7;
-    warnings: string[];
-    stats: SchemaConversionStats;
-};
-export declare enum SchemaConversionTarget {
-    OpenAI = "OPENAI",
-    JSONSchema = "JSON_SCHEMA"
-}
-export type SchemaConversionOptions = {
-    /**
-     * A target flavor.
-     */
-    target?: SchemaConversionTarget;
-    /**
-     * Keys to include
-     */
-    propertyFilter?: (key: string) => boolean;
-    /**
-     * @default false
-     */
-    inlineDefinitions?: boolean;
-    /**
-     * @default 5
-     */
-    maxDepth?: number;
-    /**
-     * Allow unknown keys when processing for the JSONSchema target.
-     *
-     * @default false
-     */
-    allowUnknownKeys?: boolean;
-};
-export declare class SchemaConverter {
-    #private;
-    warnings: string[];
-    stats: SchemaConversionStats;
-    static convert(schema: JSONSchema7, options?: SchemaConversionOptions): SchemaConversionResult;
-    protected constructor(originalSchema: JSONSchema7, options?: SchemaConversionOptions);
-    private run;
-    private processSchema;
-    private processDefinitions;
-    private countDefinitions;
-    private getUsedDefinitions;
-    private addDefinition;
-    private addNullable;
-    private processRefSchema;
-    private initializeNewSchema;
-    private processObjectSchema;
-    private processArraySchema;
-    private getUnsupportedArrayKeywords;
-    private processOneOfSchema;
-    private processAnyOfSchema;
-    private processAllOfSchema;
-    private mergeAllOfSchema;
-    private processEnumSchema;
-    private checkUnsupportedKeywords;
-}

package/dist/converters/schema-converter.js

@@ -1,558 +0,0 @@
-import { assert, ensureArray } from '@takeshape/util';
-import intersection from 'lodash/intersection.js';
-import uniq from 'lodash/uniq.js';
-import { getReferenceMap, isAllOfSchema, isAnyOfSchema, isArraySchema, isEnumSchema, isListSchema, isObjectSchema, isObjectSchemaWithProperties, isOneOfSchema, isRefSchema, isTupleSchema, pickJSONSchema7 } from "../utils/index.js";
-export var SchemaConversionTarget;
-(function (SchemaConversionTarget) {
-    SchemaConversionTarget["OpenAI"] = "OPENAI";
-    SchemaConversionTarget["JSONSchema"] = "JSON_SCHEMA";
-})(SchemaConversionTarget || (SchemaConversionTarget = {}));
-var SchemaProcessingMode;
-(function (SchemaProcessingMode) {
-    SchemaProcessingMode["Schema"] = "SCHEMA";
-    SchemaProcessingMode["Definition"] = "DEFINITION";
-    SchemaProcessingMode["Count"] = "COUNT";
-})(SchemaProcessingMode || (SchemaProcessingMode = {}));
-export class SchemaConverter {
-    warnings = [];
-    stats = {
-        propertiesCount: 0,
-        stringLength: 0,
-        enumValuesCount: 0
-    };
-    #schema;
-    #config;
-    #usedDefinitions = new Set();
-    #definitions = {};
-    #definitionsReferences = new Map();
-    static convert(schema, options = {}) {
-        return new SchemaConverter(schema, options).run();
-    }
-    constructor(originalSchema, options = {}) {
-        const { propertyFilter, target = SchemaConversionTarget.JSONSchema, inlineDefinitions = false, maxDepth = 5, allowUnknownKeys = false } = options;
-        this.#config = {
-            target,
-            maxDepth,
-            allowUnknownKeys,
-            propertyFilter,
-            inlineDefinitions
-        };
-        const { $defs, definitions, ...schema } = originalSchema;
-        this.#schema = schema;
-        if ($defs || definitions) {
-            const defs = { ...$defs, ...definitions };
-            this.#definitionsReferences = getReferenceMap(defs);
-            this.#definitions = this.processDefinitions(defs);
-        }
-    }
-    run() {
-        const { target, inlineDefinitions } = this.#config;
-        // Process the schema
-        const result = this.processSchema({
-            processingMode: SchemaProcessingMode.Schema,
-            isRequired: true,
-            path: [],
-            depth: 0
-        }, this.#schema);
-        if (!inlineDefinitions && this.#usedDefinitions.size) {
-            const defs = this.getUsedDefinitions();
-            if (Object.keys(defs).length) {
-                result.$defs = defs;
-                this.countDefinitions(defs);
-            }
-        }
-        // Check the total property count
-        if (target === SchemaConversionTarget.OpenAI && this.stats.propertiesCount > 100) {
-            this.warnings.push(`Schema has ${this.stats.propertiesCount} total object properties, exceeding the 100 limit`);
-        }
-        // Check string length total
-        if (target === SchemaConversionTarget.OpenAI && this.stats.stringLength > 15000) {
-            this.warnings.push(`Total string length of property names, definition names, enum values exceeds the 15,000 limit (${this.stats.stringLength})`);
-        }
-        // Check enum values count
-        if (target === SchemaConversionTarget.OpenAI && this.stats.enumValuesCount > 500) {
-            this.warnings.push(`Schema has ${this.stats.enumValuesCount} enum values across all properties, exceeding the 500 limit`);
-        }
-        // Check if root is an object
-        if (target === SchemaConversionTarget.OpenAI && !isObjectSchemaWithProperties(result)) {
-            this.warnings.push('Root level must be an object type, wrapping in an object');
-            // Attempt to fix by wrapping in an object if possible
-            return {
-                schema: {
-                    type: 'object',
-                    properties: {
-                        root: result
-                    },
-                    required: ['root'],
-                    additionalProperties: false
-                },
-                warnings: this.warnings,
-                stats: this.stats
-            };
-        }
-        return {
-            schema: result,
-            warnings: this.warnings,
-            stats: this.stats
-        };
-    }
-    processSchema(context, schema) {
-        assert(typeof schema === 'object', 'Schema must be an object');
-        const { depth, path, isRequired, processingMode } = context;
-        const { target, maxDepth } = this.#config;
-        // Clone the schema to avoid modifying the original
-        const schemaCopy = { ...schema };
-        const currentPath = path.join('.') || 'root';
-        // Check for unsupported keywords
-        this.checkUnsupportedKeywords(schemaCopy, currentPath);
-        // Check depth limit
-        if (depth > maxDepth) {
-            this.warnings.push(`Nesting depth exceeds limit (max 5) at ${currentPath}`);
-            // Simplify the schema at this level
-            return this.addNullable({ type: 'string', description: 'Simplified due to excessive nesting' }, isRequired);
-        }
-        // Handle $ref
-        if (isRefSchema(schemaCopy)) {
-            return this.processRefSchema(context, schemaCopy);
-        }
-        // Process specific types
-        if (isObjectSchema(schemaCopy)) {
-            return this.addNullable(this.processObjectSchema(context, schemaCopy), isRequired);
-        }
-        if (isArraySchema(schemaCopy)) {
-            return this.addNullable(this.processArraySchema(context, schemaCopy), isRequired);
-        }
-        if (isAnyOfSchema(schemaCopy)) {
-            return this.addNullable(this.processAnyOfSchema(context, schemaCopy), isRequired);
-        }
-        if (isOneOfSchema(schemaCopy)) {
-            if (target === SchemaConversionTarget.OpenAI) {
-                this.warnings.push(`oneOf at ${currentPath} converted to anyOf (OpenAI only supports anyOf)`);
-                const { oneOf, ...rest } = schemaCopy;
-                return this.addNullable(this.processAnyOfSchema(context, { ...rest, anyOf: oneOf }), isRequired);
-            }
-            return this.addNullable(this.processOneOfSchema(context, schemaCopy), isRequired);
-        }
-        if (isAllOfSchema(schemaCopy)) {
-            if (target === SchemaConversionTarget.OpenAI) {
-                this.warnings.push(`allOf at ${currentPath} is not directly supported, attempting to merge schemas`);
-                return this.addNullable(this.mergeAllOfSchema(context, schemaCopy), isRequired);
-            }
-            return this.addNullable(this.processAllOfSchema(context, schemaCopy), isRequired);
-        }
-        if (isEnumSchema(schemaCopy)) {
-            return this.addNullable(this.processEnumSchema(context, schemaCopy), isRequired);
-        }
-        if (target === SchemaConversionTarget.OpenAI && schemaCopy.default) {
-            const defaultText = `Default value: ${typeof schemaCopy.default === 'object' ? JSON.stringify(schemaCopy.default) : schemaCopy.default}`;
-            schemaCopy.description = schema.description ? `${schema.description} ${defaultText}` : defaultText;
-            // biome-ignore lint/performance/noDelete: don't want to leave cruft
-            delete schemaCopy.default;
-        }
-        // Update string length total for const values
-        if (schemaCopy.const &&
-            typeof schemaCopy.const === 'string' &&
-            (processingMode === SchemaProcessingMode.Schema || processingMode === SchemaProcessingMode.Count)) {
-            this.stats.stringLength += schemaCopy.const.length;
-        }
-        const newSchema = this.initializeNewSchema(schemaCopy, {
-            type: schemaCopy.type
-        });
-        return this.addNullable(newSchema, isRequired);
-    }
-    processDefinitions(defs) {
-        return Object.entries(defs).reduce((acc, [defName, def]) => {
-            acc[defName] = this.processSchema({
-                processingMode: SchemaProcessingMode.Definition,
-                isRequired: true,
-                path: [],
-                depth: 0
-            }, def);
-            return acc;
-        }, {});
-    }
-    countDefinitions(defs) {
-        for (const def of Object.values(defs)) {
-            this.processSchema({
-                processingMode: SchemaProcessingMode.Count,
-                isRequired: true,
-                path: [],
-                depth: 0
-            }, def);
-        }
-    }
-    getUsedDefinitions() {
-        const defs = {};
-        for (const usedDef of this.#usedDefinitions) {
-            this.addDefinition(defs, usedDef);
-            // Add any definitions that are referenced by the used definition
-            const defRefs = this.#definitionsReferences.get(usedDef);
-            if (defRefs) {
-                for (const ref of defRefs) {
-                    this.addDefinition(defs, ref);
-                }
-            }
-        }
-        return defs;
-    }
-    addDefinition(defs, key) {
-        const definition = this.#definitions[key];
-        if (definition) {
-            this.stats.stringLength += key.length;
-            defs[key] = definition;
-        }
-    }
-    addNullable(schema, isRequired) {
-        if (this.#config.target === SchemaConversionTarget.JSONSchema) {
-            return schema;
-        }
-        if (isRequired) {
-            return schema;
-        }
-        if (schema.type && !isObjectSchema(schema) && !isArraySchema(schema)) {
-            return {
-                ...schema,
-                type: uniq([...ensureArray(schema.type), 'null'])
-            };
-        }
-        return {
-            anyOf: [...(schema.anyOf ? schema.anyOf : [schema]), { type: 'null' }]
-        };
-    }
-    processRefSchema(context, schema) {
-        const { isRequired, processingMode } = context;
-        const newSchema = {
-            $ref: schema.$ref
-        };
-        // Normalize definitions path
-        if (newSchema.$ref.startsWith('#/definitions/')) {
-            newSchema.$ref = newSchema.$ref.replace('#/definitions/', '#/$defs/');
-        }
-        const defName = newSchema.$ref.replace('#/$defs/', '');
-        if (defName && this.#config.inlineDefinitions && this.#definitions[defName]) {
-            return this.processSchema(context, this.#definitions[defName]);
-        }
-        if (processingMode === SchemaProcessingMode.Schema) {
-            this.#usedDefinitions.add(defName);
-        }
-        return this.addNullable(newSchema, isRequired);
-    }
-    initializeNewSchema(schema, newSchema) {
-        // OpenAI will only allow some very specific properties, so start fairly clean
-        if (this.#config.target === SchemaConversionTarget.OpenAI) {
-            let base = {
-                title: schema.title,
-                description: schema.description
-            };
-            if (newSchema.type === 'object') {
-                base = {
-                    ...base,
-                    required: Object.keys(newSchema.properties ?? schema.properties ?? {}),
-                    additionalProperties: false
-                };
-            }
-            else if (newSchema.type === 'array') {
-                base = {
-                    ...base,
-                    items: []
-                };
-            }
-            else if (newSchema.type === 'number' ||
-                newSchema.type === 'integer' ||
-                newSchema.type === 'string' ||
-                newSchema.type === 'boolean') {
-                base = {
-                    ...base,
-                    const: schema.const
-                };
-            }
-            return {
-                ...base,
-                ...newSchema
-            };
-        }
-        return {
-            // We may be converting a schema with non-spec properties
-            ...(this.#config.allowUnknownKeys ? schema : pickJSONSchema7(schema)),
-            ...newSchema
-        };
-    }
-    processObjectSchema(context, schema) {
-        const { depth, path, processingMode } = context;
-        const { target, propertyFilter } = this.#config;
-        const newSchema = this.initializeNewSchema(schema, {
-            type: 'object'
-        });
-        const uniqueRequired = new Set(schema.required ?? []);
-        const newSchemaProperties = {};
-        // Process properties
-        if (schema.properties) {
-            // Process each property
-            for (const [key, property] of Object.entries(schema.properties)) {
-                // Skip properties that are not in propertyKeys
-                if (propertyFilter && !propertyFilter(key)) {
-                    continue;
-                }
-                newSchemaProperties[key] = this.processSchema({
-                    ...context,
-                    path: [...path, key],
-                    depth: depth + 1,
-                    isRequired: uniqueRequired.has(key)
-                }, property);
-                // Update string length total for property names
-                if (processingMode === SchemaProcessingMode.Schema || processingMode === SchemaProcessingMode.Count) {
-                    this.stats.stringLength += key.length;
-                }
-            }
-        }
-        const newPropertyKeys = Object.keys(newSchemaProperties);
-        // Update total property count
-        if (processingMode === SchemaProcessingMode.Schema || processingMode === SchemaProcessingMode.Count) {
-            this.stats.propertiesCount += newPropertyKeys.length;
-        }
-        let required = schema.required;
-        if (target === SchemaConversionTarget.OpenAI) {
-            // OpenAI requires all properties to be required
-            required = newPropertyKeys;
-        }
-        else if (required) {
-            required = intersection([...uniqueRequired], newPropertyKeys);
-        }
-        return {
-            ...newSchema,
-            properties: newSchemaProperties,
-            // Make all properties required for openai target, for json-schema some may have been removed
-            required
-        };
-    }
-    processArraySchema(context, schema) {
-        const { depth, path } = context;
-        const newSchema = this.initializeNewSchema(schema, {
-            type: 'array'
-        });
-        // Process items schema
-        if (schema.items) {
-            if (isTupleSchema(schema)) {
-                newSchema.items = schema.items.map((item, index) => this.processSchema({
-                    ...context,
-                    path: [...path, 'items', index],
-                    depth: depth + 1
-                }, item));
-            }
-            if (isListSchema(schema)) {
-                newSchema.items = this.processSchema({
-                    ...context,
-                    path: [...path, 'items'],
-                    depth: depth + 1
-                }, schema.items);
-            }
-        }
-        else {
-            this.warnings.push(`Array missing items definition at ${path.join('.') || 'root'}, defaulting to string items`);
-            newSchema.items = { type: 'string' };
-        }
-        for (const keyword of this.getUnsupportedArrayKeywords()) {
-            if (schema[keyword] !== undefined) {
-                this.warnings.push(`Unsupported array keyword "${keyword}" at ${path.join('.') || 'root'} will be ignored`);
-            }
-        }
-        return newSchema;
-    }
-    getUnsupportedArrayKeywords() {
-        if (this.#config.target === SchemaConversionTarget.OpenAI) {
-            return [
-                // 'unevaluatedItems',
-                'contains',
-                // 'minContains',
-                // 'maxContains',
-                'minItems',
-                'maxItems',
-                'uniqueItems'
-            ];
-        }
-        return [];
-    }
-    processOneOfSchema(context, schema) {
-        const { depth, path } = context;
-        const newSchema = this.initializeNewSchema(schema, {
-            oneOf: []
-        });
-        // Process each oneOf schema
-        newSchema.oneOf = schema.oneOf.map((subSchema, index) => {
-            return this.processSchema({ ...context, path: [...path, 'oneOf', index], depth: depth + 1 }, subSchema);
-        });
-        return newSchema;
-    }
-    processAnyOfSchema(context, schema) {
-        const { target } = this.#config;
-        const { depth, path } = context;
-        const newSchema = this.initializeNewSchema(schema, {
-            anyOf: []
-        });
-        // Check if this is at the root level
-        if (target === SchemaConversionTarget.OpenAI && path.length === 0) {
-            this.warnings.push('anyOf at root level is not supported by OpenAI Structured Outputs');
-        }
-        // Process each anyOf schema
-        newSchema.anyOf = schema.anyOf.map((subSchema, index) => {
-            return this.processSchema({ ...context, path: [...path, 'anyOf', index], depth: depth + 1 }, subSchema);
-        });
-        return newSchema;
-    }
-    processAllOfSchema(context, schema) {
-        const { depth, path } = context;
-        const newSchema = this.initializeNewSchema(schema, {
-            allOf: []
-        });
-        // Process each anyOf schema
-        newSchema.allOf = schema.allOf.map((subSchema, index) => {
-            return this.processSchema({ ...context, path: [...path, 'allOf', index], depth: depth + 1 }, subSchema);
-        });
-        return newSchema;
-    }
-    mergeAllOfSchema(context, schema) {
-        const { depth, path } = context;
-        const newSchema = this.initializeNewSchema(schema, {
-            type: 'object'
-        });
-        const allOfSchemas = schema.allOf ?? [];
-        // Try to merge properties from all schemas
-        for (const [index, value] of allOfSchemas.entries()) {
-            const subSchema = this.processSchema({ ...context, path: [...path, 'allOf', index] }, value);
-            if (isObjectSchemaWithProperties(subSchema)) {
-                // Merge properties
-                newSchema.properties = {
-                    ...newSchema.properties,
-                    ...subSchema.properties
-                };
-                // Merge required fields
-                if (Array.isArray(subSchema.required)) {
-                    newSchema.required = [...(newSchema.required ?? []), ...subSchema.required];
-                }
-                // Preserve description if we don't have one yet
-                if (!newSchema.description && subSchema.description) {
-                    newSchema.description = subSchema.description;
-                }
-                // Preserve title if we don't have one yet
-                if (!newSchema.title && subSchema.title) {
-                    newSchema.title = subSchema.title;
-                }
-            }
-            else {
-                this.warnings.push(`Non-object schema in allOf at ${path.join('.') || 'root'} cannot be merged properly`);
-            }
-        }
-        // Remove duplicate required fields
-        newSchema.required = [...new Set(newSchema.required)];
-        return this.processObjectSchema({ ...context, depth: depth + 1 }, newSchema);
-    }
-    processEnumSchema(context, schema) {
-        const { target } = this.#config;
-        const { path, processingMode } = context;
-        const newSchema = this.initializeNewSchema(schema, {
-            enum: schema.enum,
-            type: schema.type
-        });
-        if (Array.isArray(newSchema.enum)) {
-            // Update enum values count
-            if (processingMode === SchemaProcessingMode.Schema || processingMode === SchemaProcessingMode.Count) {
-                this.stats.enumValuesCount += newSchema.enum.length;
-            }
-            // Check enum size
-            if (target === SchemaConversionTarget.OpenAI && newSchema.enum.length > 500) {
-                this.warnings.push(`Enum at ${path.join('.') || 'root'} has ${newSchema.enum.length} values, exceeding the 500 limit`);
-                newSchema.enum = newSchema.enum.slice(0, 500);
-            }
-            // Check string length for large enums
-            if (newSchema.type === 'string') {
-                let totalLength = 0;
-                for (const val of newSchema.enum) {
-                    if (typeof val === 'string') {
-                        totalLength += val.length;
-                    }
-                }
-                if (target === SchemaConversionTarget.OpenAI && totalLength > 7500) {
-                    this.warnings.push(`Enum strings at ${path.join('.') || 'root'} exceed 7500 characters (${totalLength}) with ${newSchema.enum.length} values`);
-                    // Truncate enum values to fit within limits
-                    let currentLength = 0;
-                    const truncatedEnum = [];
-                    for (const val of newSchema.enum) {
-                        if (typeof val === 'string') {
-                            if (currentLength + val.length <= 7500) {
-                                truncatedEnum.push(val);
-                                currentLength += val.length;
-                            }
-                            else {
-                                break;
-                            }
-                        }
-                        else {
-                            truncatedEnum.push(val);
-                        }
-                    }
-                    newSchema.enum = truncatedEnum;
-                }
-                if (processingMode === SchemaProcessingMode.Schema || processingMode === SchemaProcessingMode.Count) {
-                    this.stats.stringLength += totalLength;
-                }
-            }
-        }
-        return newSchema;
-    }
-    checkUnsupportedKeywords(schema, path) {
-        if (this.#config.target === SchemaConversionTarget.OpenAI) {
-            // String-specific unsupported keywords
-            if (schema.type === 'string' ||
-                (!schema.type &&
-                    (schema.minLength !== undefined ||
-                        schema.maxLength !== undefined ||
-                        schema.pattern !== undefined ||
-                        schema.format !== undefined))) {
-                const unsupportedStringKeywords = ['minLength', 'maxLength', 'pattern', 'format'];
-                for (const keyword of unsupportedStringKeywords) {
-                    if (schema[keyword] !== undefined) {
-                        this.warnings.push(`Unsupported string keyword "${keyword}" at ${path || 'root'} will be ignored`);
-                        delete schema[keyword];
-                    }
-                }
-            }
-            // Number-specific unsupported keywords
-            if (schema.type === 'number' ||
-                schema.type === 'integer' ||
-                (!schema.type &&
-                    (schema.minimum !== undefined || schema.maximum !== undefined || schema.multipleOf !== undefined))) {
-                const unsupportedNumberKeywords = ['minimum', 'maximum', 'multipleOf'];
-                for (const keyword of unsupportedNumberKeywords) {
-                    if (schema[keyword] !== undefined) {
-                        this.warnings.push(`Unsupported number keyword "${keyword}" at ${path || 'root'} will be ignored`);
-                        delete schema[keyword];
-                    }
-                }
-            }
-            // Object-specific unsupported keywords
-            if (schema.type === 'object' || (!schema.type && schema.properties !== undefined)) {
-                const unsupportedObjectKeywords = [
-                    'patternProperties',
-                    // 'unevaluatedProperties',
-                    'propertyNames',
-                    'minProperties',
-                    'maxProperties'
-                ];
-                for (const keyword of unsupportedObjectKeywords) {
-                    if (schema[keyword] !== undefined) {
-                        this.warnings.push(`Unsupported object keyword "${keyword}" at ${path || 'root'} will be ignored`);
-                        delete schema[keyword];
-                    }
-                }
-            }
-            // Check Draft 7 keywords that aren't supported in OpenAI schema
-            const draft7Keywords = ['if', 'then', 'else', 'not', 'dependencies'];
-            for (const keyword of draft7Keywords) {
-                if (schema[keyword] !== undefined) {
-                    this.warnings.push(`JSON Schema Draft 7 keyword "${keyword}" at ${path || 'root'} is not supported and will be ignored`);
-                    delete schema[keyword];
-                }
-            }
-        }
-    }
-}

package/dist/index.d.ts

@@ -1 +0,0 @@
-export * from './schema-validator.ts';

package/dist/index.js

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

package/dist/schema-validator.d.ts

@@ -1,36 +0,0 @@
-import type { ErrorObject, Options, SchemaObject } from 'ajv';
-import { Ajv } from 'ajv';
-import type { JSONSchema7 } from 'json-schema';
-export type Data = any;
-export type ValidateParams = {
-    ignoreMissing: boolean;
-    ignoreNulls: boolean;
-    errorsText: boolean;
-};
-export type ValidateResult = {
-    valid: boolean;
-    errorsText: string;
-    errors: ErrorObject[];
-};
-export type Validator = (data: Data, options?: Partial<ValidateParams>) => ValidateResult;
-export declare function parseDataPath(instancePath: string): string[];
-export declare function isInvalidPropertyRequired(topLevelSchema: SchemaObject, error: ErrorObject): boolean;
-export declare function refToPath(ref: string): string[];
-/**
- * Given a schema object traverse it using a "instancePath" and return the schema at that path
- */
-export declare function followSchemaPath(topLevelSchema: SchemaObject, instancePath: string[]): SchemaObject | undefined;
-export type MinimalAjv = Pick<Ajv, 'validate' | 'errors' | 'getSchema' | 'errorsText'>;
-export declare function validate(ajv: MinimalAjv, id: string, data: Data, options?: Partial<ValidateParams>): ValidateResult;
-export { Ajv, type ErrorObject };
-export declare function createAjv(options?: Options): Ajv;
-/**
- * Apply various fixes to the schema to work around AJV issues and bugs.
- * See inline comments for more.
- */
-export declare function fixSchema(schema: SchemaObject): SchemaObject;
-export declare function createSchemaValidator(schema: SchemaObject | SchemaObject[], metaSchemas?: SchemaObject[], options?: Options): Validator;
-/**
- * Returns a compiled validator from a schema which can act as a type guard.
- */
-export declare function createTypedValidator<T>(schema: JSONSchema7, options?: Options): import("ajv").ValidateFunction<T>;