z-schema 7.0.0 → 7.0.6

package/dist/{SchemaValidation.js → schema-validator.js}

@@ -1,7 +1,9 @@
-import { FormatValidators } from './FormatValidators.js';
-import * as JsonValidation from './JsonValidation.js';
-import { Report } from './Report.js';
-import * as Utils from './Utils.js';
+import { validate } from './json-validation.js';
+import { Report } from './report.js';
+import { isObject, whatIs } from './utils/what-is.js';
+import { shallowClone } from './utils/clone.js';
+import { isUniqueArray } from './utils/array.js';
+import { isFormatSupported } from './format-validators.js';
 const SchemaValidators = {
     $ref: function (report, schema) {
         // http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-07
@@ -57,7 +59,7 @@ const SchemaValidators = {
     },
     maxLength: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.1.1
-        if (Utils.whatIs(schema.maxLength) !== 'integer') {
+        if (whatIs(schema.maxLength) !== 'integer') {
             report.addError('KEYWORD_TYPE_EXPECTED', ['maxLength', 'integer']);
         }
         else if (schema.maxLength < 0) {
@@ -66,7 +68,7 @@ const SchemaValidators = {
     },
     minLength: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.2.1
-        if (Utils.whatIs(schema.minLength) !== 'integer') {
+        if (whatIs(schema.minLength) !== 'integer') {
             report.addError('KEYWORD_TYPE_EXPECTED', ['minLength', 'integer']);
         }
         else if (schema.minLength < 0) {
@@ -89,30 +91,30 @@ const SchemaValidators = {
     },
     additionalItems: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.1.1
-        const type = Utils.whatIs(schema.additionalItems);
+        const type = whatIs(schema.additionalItems);
         if (type !== 'boolean' && type !== 'object') {
             report.addError('KEYWORD_TYPE_EXPECTED', ['additionalItems', ['boolean', 'object']]);
         }
-        else if (type === 'object') {
+        else if (isObject(schema.additionalItems)) {
             report.path.push('additionalItems');
-            validateSchema.call(this, report, schema.additionalItems);
+            this.validateSchema(report, schema.additionalItems);
             report.path.pop();
         }
     },
     items: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.1.1
-        const type = Utils.whatIs(schema.items);
+        const type = whatIs(schema.items);
         if (type === 'object') {
             report.path.push('items');
-            validateSchema.call(this, report, schema.items);
+            this.validateSchema(report, schema.items);
             report.path.pop();
         }
-        else if (type === 'array') {
+        else if (Array.isArray(schema.items)) {
             let idx = schema.items.length;
             while (idx--) {
                 report.path.push('items');
-                report.path.push(idx.toString());
-                validateSchema.call(this, report, schema.items[idx]);
+                report.path.push(idx);
+                this.validateSchema(report, schema.items[idx]);
                 report.path.pop();
                 report.path.pop();
             }
@@ -140,7 +142,7 @@ const SchemaValidators = {
     },
     minItems: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.3.1
-        if (Utils.whatIs(schema.minItems) !== 'integer') {
+        if (whatIs(schema.minItems) !== 'integer') {
             report.addError('KEYWORD_TYPE_EXPECTED', ['minItems', 'integer']);
         }
         else if (schema.minItems < 0) {
@@ -155,7 +157,7 @@ const SchemaValidators = {
     },
     maxProperties: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.1.1
-        if (Utils.whatIs(schema.maxProperties) !== 'integer') {
+        if (whatIs(schema.maxProperties) !== 'integer') {
             report.addError('KEYWORD_TYPE_EXPECTED', ['maxProperties', 'integer']);
         }
         else if (schema.maxProperties < 0) {
@@ -164,7 +166,7 @@ const SchemaValidators = {
     },
     minProperties: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.2.1
-        if (Utils.whatIs(schema.minProperties) !== 'integer') {
+        if (whatIs(schema.minProperties) !== 'integer') {
             report.addError('KEYWORD_TYPE_EXPECTED', ['minProperties', 'integer']);
         }
         else if (schema.minProperties < 0) {
@@ -173,7 +175,7 @@ const SchemaValidators = {
     },
     required: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.3.1
-        if (Utils.whatIs(schema.required) !== 'array') {
+        if (whatIs(schema.required) !== 'array') {
             report.addError('KEYWORD_TYPE_EXPECTED', ['required', 'array']);
         }
         else if (schema.required.length === 0) {
@@ -186,36 +188,37 @@ const SchemaValidators = {
                     report.addError('KEYWORD_VALUE_TYPE', ['required', 'string']);
                 }
             }
-            if (Utils.isUniqueArray(schema.required) === false) {
+            if (isUniqueArray(schema.required) === false) {
                 report.addError('KEYWORD_MUST_BE', ['required', 'an array with unique items']);
             }
         }
     },
     additionalProperties: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.4.1
-        const type = Utils.whatIs(schema.additionalProperties);
+        const type = whatIs(schema.additionalProperties);
         if (type !== 'boolean' && type !== 'object') {
             report.addError('KEYWORD_TYPE_EXPECTED', ['additionalProperties', ['boolean', 'object']]);
         }
-        else if (type === 'object') {
+        else if (isObject(schema.additionalProperties)) {
             report.path.push('additionalProperties');
-            validateSchema.call(this, report, schema.additionalProperties);
+            this.validateSchema(report, schema.additionalProperties);
             report.path.pop();
         }
     },
     properties: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.4.1
-        if (Utils.whatIs(schema.properties) !== 'object') {
+        if (whatIs(schema.properties) !== 'object') {
             report.addError('KEYWORD_TYPE_EXPECTED', ['properties', 'object']);
             return;
         }
         const keys = Object.keys(schema.properties);
         let idx = keys.length;
         while (idx--) {
-            const key = keys[idx], val = schema.properties[key];
+            const key = keys[idx];
+            const val = schema.properties[key];
             report.path.push('properties');
             report.path.push(key);
-            validateSchema.call(this, report, val);
+            this.validateSchema(report, val);
             report.path.pop();
             report.path.pop();
         }
@@ -234,7 +237,7 @@ const SchemaValidators = {
     },
     patternProperties: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.4.1
-        if (Utils.whatIs(schema.patternProperties) !== 'object') {
+        if (whatIs(schema.patternProperties) !== 'object') {
             report.addError('KEYWORD_TYPE_EXPECTED', ['patternProperties', 'object']);
             return;
         }
@@ -249,8 +252,8 @@ const SchemaValidators = {
                 report.addError('KEYWORD_PATTERN', ['patternProperties', key]);
             }
             report.path.push('patternProperties');
-            report.path.push(key.toString());
-            validateSchema.call(this, report, val);
+            report.path.push(key);
+            this.validateSchema(report, val);
             report.path.pop();
             report.path.pop();
         }
@@ -261,18 +264,20 @@ const SchemaValidators = {
     },
     dependencies: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.5.1
-        if (Utils.whatIs(schema.dependencies) !== 'object') {
+        if (whatIs(schema.dependencies) !== 'object') {
             report.addError('KEYWORD_TYPE_EXPECTED', ['dependencies', 'object']);
         }
         else {
             const keys = Object.keys(schema.dependencies);
             let idx = keys.length;
             while (idx--) {
-                const schemaKey = keys[idx], schemaDependency = schema.dependencies[schemaKey], type = Utils.whatIs(schemaDependency);
+                const schemaKey = keys[idx];
+                const schemaDependency = schema.dependencies[schemaKey];
+                const type = whatIs(schemaDependency);
                 if (type === 'object') {
                     report.path.push('dependencies');
                     report.path.push(schemaKey);
-                    validateSchema.call(this, report, schemaDependency);
+                    this.validateSchema(report, schemaDependency);
                     report.path.pop();
                     report.path.pop();
                 }
@@ -286,7 +291,7 @@ const SchemaValidators = {
                             report.addError('KEYWORD_VALUE_TYPE', ['dependensices', 'string']);
                         }
                     }
-                    if (Utils.isUniqueArray(schemaDependency) === false) {
+                    if (isUniqueArray(schemaDependency) === false) {
                         report.addError('KEYWORD_MUST_BE', ['dependencies', 'an array with unique items']);
                     }
                 }
@@ -304,21 +309,23 @@ const SchemaValidators = {
         else if (schema.enum.length === 0) {
             report.addError('KEYWORD_MUST_BE', ['enum', 'an array with at least one element']);
         }
-        else if (Utils.isUniqueArray(schema.enum) === false) {
+        else if (isUniqueArray(schema.enum) === false) {
             report.addError('KEYWORD_MUST_BE', ['enum', 'an array with unique elements']);
         }
     },
     type: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.2.1
-        const primitiveTypes = ['array', 'boolean', 'integer', 'number', 'null', 'object', 'string'], primitiveTypeStr = primitiveTypes.join(','), isArray = Array.isArray(schema.type);
-        if (isArray) {
+        const primitiveTypes = ['array', 'boolean', 'integer', 'number', 'null', 'object', 'string'];
+        const primitiveTypeStr = primitiveTypes.join(',');
+        const isArray = Array.isArray(schema.type);
+        if (Array.isArray(schema.type)) {
             let idx = schema.type.length;
             while (idx--) {
                 if (primitiveTypes.indexOf(schema.type[idx]) === -1) {
                     report.addError('KEYWORD_TYPE_EXPECTED', ['type', primitiveTypeStr]);
                 }
             }
-            if (Utils.isUniqueArray(schema.type) === false) {
+            if (isUniqueArray(schema.type) === false) {
                 report.addError('KEYWORD_MUST_BE', ['type', 'an object with unique properties']);
             }
         }
@@ -405,8 +412,8 @@ const SchemaValidators = {
             let idx = schema.allOf.length;
             while (idx--) {
                 report.path.push('allOf');
-                report.path.push(idx.toString());
-                validateSchema.call(this, report, schema.allOf[idx]);
+                report.path.push(idx);
+                this.validateSchema(report, schema.allOf[idx]);
                 report.path.pop();
                 report.path.pop();
             }
@@ -424,8 +431,8 @@ const SchemaValidators = {
             let idx = schema.anyOf.length;
             while (idx--) {
                 report.path.push('anyOf');
-                report.path.push(idx.toString());
-                validateSchema.call(this, report, schema.anyOf[idx]);
+                report.path.push(idx);
+                this.validateSchema(report, schema.anyOf[idx]);
                 report.path.pop();
                 report.path.pop();
             }
@@ -443,8 +450,8 @@ const SchemaValidators = {
             let idx = schema.oneOf.length;
             while (idx--) {
                 report.path.push('oneOf');
-                report.path.push(idx.toString());
-                validateSchema.call(this, report, schema.oneOf[idx]);
+                report.path.push(idx);
+                this.validateSchema(report, schema.oneOf[idx]);
                 report.path.pop();
                 report.path.pop();
             }
@@ -452,18 +459,18 @@ const SchemaValidators = {
     },
     not: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.6.1
-        if (Utils.whatIs(schema.not) !== 'object') {
+        if (whatIs(schema.not) !== 'object') {
             report.addError('KEYWORD_TYPE_EXPECTED', ['not', 'object']);
         }
         else {
             report.path.push('not');
-            validateSchema.call(this, report, schema.not);
+            this.validateSchema(report, schema.not);
             report.path.pop();
         }
     },
     definitions: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.7.1
-        if (Utils.whatIs(schema.definitions) !== 'object') {
+        if (whatIs(schema.definitions) !== 'object') {
             report.addError('KEYWORD_TYPE_EXPECTED', ['definitions', 'object']);
         }
         else {
@@ -473,7 +480,7 @@ const SchemaValidators = {
                 const key = keys[idx], val = schema.definitions[key];
                 report.path.push('definitions');
                 report.path.push(key);
-                validateSchema.call(this, report, val);
+                this.validateSchema(report, val);
                 report.path.pop();
                 report.path.pop();
             }
@@ -484,7 +491,7 @@ const SchemaValidators = {
             report.addError('KEYWORD_TYPE_EXPECTED', ['format', 'string']);
         }
         else {
-            if (FormatValidators[schema.format] === undefined && this.options.ignoreUnknownFormats !== true) {
+            if (!isFormatSupported(schema.format) && this.options.ignoreUnknownFormats !== true) {
                 report.addError('UNKNOWN_FORMAT', [schema.format]);
             }
         }
@@ -507,125 +514,122 @@ const SchemaValidators = {
             report.addError('KEYWORD_TYPE_EXPECTED', ['description', 'string']);
         }
     },
-    default: function ( /* report, schema */) {
+    default: function () {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.6.2
         // There are no restrictions placed on the value of this keyword.
     },
 };
-/**
- *
- * @param {Report} report
- * @param {*[]} arr
- *
- * @returns {boolean}
- */
-const validateArrayOfSchemas = function (report, arr) {
-    let idx = arr.length;
-    while (idx--) {
-        validateSchema.call(this, report, arr[idx]);
+export class SchemaValidator {
+    validator;
+    constructor(validator) {
+        this.validator = validator;
     }
-    return report.isValid();
-};
-/**
- *
- * @param {Report} report
- * @param {*} schema
- */
-export function validateSchema(report, schema) {
-    report.commonErrorMessage = 'SCHEMA_VALIDATION_FAILED';
-    // if schema is an array, assume it's an array of schemas
-    if (Array.isArray(schema)) {
-        return validateArrayOfSchemas.call(this, report, schema);
+    get options() {
+        return this.validator.options;
     }
-    // do not revalidate schema that has already been validated once
-    if (schema.__$validated) {
-        return true;
+    validateArrayOfSchemas(report, arr) {
+        let idx = arr.length;
+        while (idx--) {
+            this.validateSchema(report, arr[idx]);
+        }
+        return report.isValid();
     }
-    // if $schema is present, this schema should validate against that $schema
-    const hasParentSchema = schema.$schema && schema.id !== schema.$schema;
-    if (hasParentSchema) {
-        if (schema.__$schemaResolved && schema.__$schemaResolved !== schema) {
-            const subReport = new Report(report);
-            const valid = JsonValidation.validate.call(this, subReport, schema.__$schemaResolved, schema);
-            if (valid === false) {
-                report.addError('PARENT_SCHEMA_VALIDATION_FAILED', null, subReport);
+    validateSchema(report, schema) {
+        report.commonErrorMessage = 'SCHEMA_VALIDATION_FAILED';
+        // if schema is an array, assume it's an array of schemas
+        if (Array.isArray(schema)) {
+            return this.validateArrayOfSchemas(report, schema);
+        }
+        // do not revalidate schema that has already been validated once
+        if (schema.__$validated) {
+            return true;
+        }
+        // if $schema is present, this schema should validate against that $schema
+        const hasParentSchema = schema.$schema && schema.id !== schema.$schema;
+        if (hasParentSchema) {
+            if (schema.__$schemaResolved && schema.__$schemaResolved !== schema) {
+                const subReport = new Report(report);
+                const valid = validate.call(this.validator, subReport, schema.__$schemaResolved, schema);
+                if (valid === false) {
+                    report.addError('PARENT_SCHEMA_VALIDATION_FAILED', undefined, subReport);
+                }
             }
-        }
-        else {
-            if (this.options.ignoreUnresolvableReferences !== true) {
-                report.addError('REF_UNRESOLVED', [schema.$schema]);
+            else {
+                if (this.validator.options.ignoreUnresolvableReferences !== true) {
+                    report.addError('REF_UNRESOLVED', [schema.$schema]);
+                }
             }
         }
-    }
-    if (this.options.noTypeless === true) {
-        // issue #36 - inherit type to anyOf, oneOf, allOf if noTypeless is defined
-        if (schema.type !== undefined) {
-            let schemas = [];
-            if (Array.isArray(schema.anyOf)) {
-                schemas = schemas.concat(schema.anyOf);
-            }
-            if (Array.isArray(schema.oneOf)) {
-                schemas = schemas.concat(schema.oneOf);
-            }
-            if (Array.isArray(schema.allOf)) {
-                schemas = schemas.concat(schema.allOf);
-            }
-            schemas.forEach(function (sch) {
-                if (!sch.type) {
-                    sch.type = schema.type;
+        if (this.validator.options.noTypeless === true) {
+            // issue #36 - inherit type to anyOf, oneOf, allOf if noTypeless is defined
+            if (schema.type !== undefined) {
+                let schemas = [];
+                if (Array.isArray(schema.anyOf)) {
+                    schemas = schemas.concat(schema.anyOf);
                 }
-            });
-        }
-        // end issue #36
-        if (schema.enum === undefined &&
-            schema.type === undefined &&
-            schema.anyOf === undefined &&
-            schema.oneOf === undefined &&
-            schema.not === undefined &&
-            schema.$ref === undefined) {
-            report.addError('KEYWORD_UNDEFINED_STRICT', ['type']);
-        }
-    }
-    const keys = Object.keys(schema);
-    let idx = keys.length;
-    while (idx--) {
-        const key = keys[idx];
-        if (key.indexOf('__') === 0) {
-            continue;
-        }
-        if (SchemaValidators[key] !== undefined) {
-            SchemaValidators[key].call(this, report, schema);
+                if (Array.isArray(schema.oneOf)) {
+                    schemas = schemas.concat(schema.oneOf);
+                }
+                if (Array.isArray(schema.allOf)) {
+                    schemas = schemas.concat(schema.allOf);
+                }
+                schemas.forEach(function (sch) {
+                    if (!sch.type) {
+                        sch.type = schema.type;
+                    }
+                });
+            }
+            // end issue #36
+            if (schema.enum === undefined &&
+                schema.type === undefined &&
+                schema.anyOf === undefined &&
+                schema.oneOf === undefined &&
+                schema.not === undefined &&
+                schema.$ref === undefined) {
+                report.addError('KEYWORD_UNDEFINED_STRICT', ['type']);
+            }
         }
-        else if (!hasParentSchema) {
-            if (this.options.noExtraKeywords === true) {
-                report.addError('KEYWORD_UNEXPECTED', [key]);
+        const keys = Object.keys(schema);
+        let idx = keys.length;
+        while (idx--) {
+            const key = keys[idx];
+            if (key.indexOf('__') === 0) {
+                continue;
+            }
+            if (Object.prototype.hasOwnProperty.call(SchemaValidators, key)) {
+                SchemaValidators[key].call(this, report, schema);
+            }
+            else if (!hasParentSchema) {
+                if (this.validator.options.noExtraKeywords === true) {
+                    report.addError('KEYWORD_UNEXPECTED', [key]);
+                }
             }
         }
-    }
-    if (this.options.pedanticCheck === true) {
-        if (schema.enum) {
-            // break recursion
-            const tmpSchema = Utils.clone(schema);
-            delete tmpSchema.enum;
-            delete tmpSchema.default;
-            report.path.push('enum');
-            idx = schema.enum.length;
-            while (idx--) {
-                report.path.push(idx.toString());
-                JsonValidation.validate.call(this, report, tmpSchema, schema.enum[idx]);
+        if (this.validator.options.pedanticCheck === true) {
+            if (schema.enum) {
+                // break recursion
+                const tmpSchema = shallowClone(schema);
+                delete tmpSchema.enum;
+                delete tmpSchema.default;
+                report.path.push('enum');
+                idx = schema.enum.length;
+                while (idx--) {
+                    report.path.push(idx);
+                    validate.call(this.validator, report, tmpSchema, schema.enum[idx]);
+                    report.path.pop();
+                }
+                report.path.pop();
+            }
+            if (schema.default) {
+                report.path.push('default');
+                validate.call(this.validator, report, schema, schema.default);
                 report.path.pop();
             }
-            report.path.pop();
         }
-        if (schema.default) {
-            report.path.push('default');
-            JsonValidation.validate.call(this, report, schema, schema.default);
-            report.path.pop();
+        const isValid = report.isValid();
+        if (isValid) {
+            schema.__$validated = true;
         }
+        return isValid;
     }
-    const isValid = report.isValid();
-    if (isValid) {
-        schema.__$validated = true;
-    }
-    return isValid;
 }

package/dist/types/{Errors.d.ts → errors.d.ts}

@@ -1,3 +1,5 @@
+export type ErrorCode = keyof typeof Errors;
+export type ErrorParam = string | number | Array<string | number>;
 export declare const Errors: {
     INVALID_TYPE: string;
     INVALID_FORMAT: string;

package/dist/types/format-validators.d.ts

@@ -0,0 +1,10 @@
+export type FormatValidatorFn = (input: unknown) => boolean;
+export interface FormatValidatorsOptions {
+    strictUris?: boolean;
+}
+export declare function getFormatValidators(options?: FormatValidatorsOptions): Record<string, FormatValidatorFn>;
+export declare function registerFormat(name: string, validatorFunction: FormatValidatorFn): void;
+export declare function unregisterFormat(name: string): void;
+export declare function getSupportedFormats(): string[];
+export declare function isFormatSupported(name: string): boolean;
+export declare function getRegisteredFormats(): string[];

package/dist/types/index.d.ts

@@ -1,2 +1,11 @@
-import { ZSchema } from './ZSchema.js';
+import { ZSchema } from './z-schema.js';
+export type * from './errors.js';
+export type * from './format-validators.js';
+export type * from './json-schema.js';
+export type * from './json-validation.js';
+export type * from './report.js';
+export type * from './schema-cache.js';
+export type * from './schema-compiler.js';
+export type * from './schema-validator.js';
+export type * from './z-schema.js';
 export default ZSchema;

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

@@ -0,0 +1,50 @@
+import { Reference } from './schema-compiler.js';
+export interface JsonSchema {
+    $ref?: string;
+    id?: string;
+    $schema?: string;
+    title?: string;
+    description?: string;
+    default?: unknown;
+    definitions?: Record<string, JsonSchema>;
+    type?: string | string[];
+    properties?: Record<string, JsonSchema>;
+    patternProperties?: Record<string, JsonSchema>;
+    dependencies?: Record<string, string[]>;
+    multipleOf?: number;
+    minimum?: number;
+    exclusiveMinimum?: boolean;
+    maximum?: number;
+    exclusiveMaximum?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    additionalItems?: boolean | JsonSchema;
+    items?: JsonSchema | JsonSchema[];
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    minProperties?: number;
+    maxProperties?: number;
+    required?: string[];
+    additionalProperties?: boolean | JsonSchema;
+    enum?: Array<unknown>;
+    format?: string;
+    allOf?: JsonSchema[];
+    anyOf?: JsonSchema[];
+    oneOf?: JsonSchema[];
+    not?: JsonSchema;
+}
+export type JsonSchemaType = 'array' | 'boolean' | 'integer' | 'null' | 'number' | 'object' | 'string';
+export interface ZSchemaInternalProperties {
+    __$compiled?: unknown;
+    __$missingReferences?: Reference[];
+    __$refResolved?: JsonSchema;
+    __$schemaResolved?: unknown;
+    __$validated?: boolean;
+    __$validationOptions?: unknown;
+    __$visited?: boolean;
+}
+export interface JsonSchemaInternal extends JsonSchema, ZSchemaInternalProperties {
+}
+export declare const findId: (schema: JsonSchemaInternal, id: string) => JsonSchemaInternal | undefined;

package/dist/types/json-validation.d.ts

@@ -0,0 +1,7 @@
+import { Report } from './report.js';
+import { JsonSchema, JsonSchemaInternal } from './json-schema.js';
+import type { ZSchema } from './z-schema.js';
+type JsonValidatorFn = (this: ZSchema, report: Report, schema: JsonSchemaInternal, json: unknown) => void;
+export declare const JsonValidators: Record<keyof JsonSchema, JsonValidatorFn>;
+export declare function validate(this: ZSchema, report: Report, schema: JsonSchemaInternal, json: unknown): boolean;
+export {};