z-schema 9.0.1 → 10.0.0

package/dist/schema-validator.js

@@ -1,10 +1,11 @@
 import { isFormatSupported } from './format-validators.js';
+import { getId } from './json-schema.js';
 import { validate } from './json-validation.js';
 import { Report } from './report.js';
 import { isUniqueArray } from './utils/array.js';
 import { shallowClone } from './utils/clone.js';
 import { compileSchemaRegex } from './utils/schema-regex.js';
-import { isObject, whatIs } from './utils/what-is.js';
+import { isInteger, isObject } from './utils/what-is.js';
 const SchemaValidators = {
     $ref: function (report, schema) {
         // http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-07
@@ -36,11 +37,18 @@ const SchemaValidators = {
     },
     exclusiveMaximum: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.2.1
-        if (typeof schema.exclusiveMaximum !== 'boolean') {
-            report.addError('KEYWORD_TYPE_EXPECTED', ['exclusiveMaximum', 'boolean'], undefined, schema, 'exclusiveMaximum');
+        if (report.options.version === 'draft-04') {
+            if (typeof schema.exclusiveMaximum !== 'boolean') {
+                report.addError('KEYWORD_TYPE_EXPECTED', ['exclusiveMaximum', 'boolean'], undefined, schema, 'exclusiveMaximum');
+            }
+            else if (schema.maximum === undefined) {
+                report.addError('KEYWORD_DEPENDENCY', ['exclusiveMaximum', 'maximum'], undefined, schema, 'exclusiveMaximum');
+            }
         }
-        else if (schema.maximum === undefined) {
-            report.addError('KEYWORD_DEPENDENCY', ['exclusiveMaximum', 'maximum'], undefined, schema, 'exclusiveMaximum');
+        else {
+            if (typeof schema.exclusiveMaximum !== 'boolean' && typeof schema.exclusiveMaximum !== 'number') {
+                report.addError('KEYWORD_TYPE_EXPECTED', ['exclusiveMaximum', ['boolean', 'number']], undefined, schema, 'exclusiveMaximum');
+            }
         }
     },
     minimum: function (report, schema) {
@@ -50,17 +58,24 @@ const SchemaValidators = {
         }
     },
     exclusiveMinimum: function (report, schema) {
-        // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.3.1
-        if (typeof schema.exclusiveMinimum !== 'boolean') {
-            report.addError('KEYWORD_TYPE_EXPECTED', ['exclusiveMinimum', 'boolean'], undefined, schema, 'exclusiveMinimum');
+        if (report.options.version === 'draft-04') {
+            // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.3.1
+            if (typeof schema.exclusiveMinimum !== 'boolean') {
+                report.addError('KEYWORD_TYPE_EXPECTED', ['exclusiveMinimum', 'boolean'], undefined, schema, 'exclusiveMinimum');
+            }
+            else if (schema.minimum === undefined) {
+                report.addError('KEYWORD_DEPENDENCY', ['exclusiveMinimum', 'minimum'], undefined, schema, 'exclusiveMinimum');
+            }
         }
-        else if (schema.minimum === undefined) {
-            report.addError('KEYWORD_DEPENDENCY', ['exclusiveMinimum', 'minimum'], undefined, schema, 'exclusiveMinimum');
+        else {
+            if (typeof schema.exclusiveMinimum !== 'boolean' && typeof schema.exclusiveMinimum !== 'number') {
+                report.addError('KEYWORD_TYPE_EXPECTED', ['exclusiveMinimum', ['boolean', 'number']], undefined, schema, 'exclusiveMinimum');
+            }
         }
     },
     maxLength: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.1.1
-        if (whatIs(schema.maxLength) !== 'integer') {
+        if (!isInteger(schema.maxLength)) {
             report.addError('KEYWORD_TYPE_EXPECTED', ['maxLength', 'integer'], undefined, schema, 'maxLength');
         }
         else if (schema.maxLength < 0) {
@@ -69,7 +84,7 @@ const SchemaValidators = {
     },
     minLength: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.2.1
-        if (whatIs(schema.minLength) !== 'integer') {
+        if (!isInteger(schema.minLength)) {
             report.addError('KEYWORD_TYPE_EXPECTED', ['minLength', 'integer'], undefined, schema, 'minLength');
         }
         else if (schema.minLength < 0) {
@@ -92,8 +107,7 @@ const SchemaValidators = {
     },
     additionalItems: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.1.1
-        const type = whatIs(schema.additionalItems);
-        if (type !== 'boolean' && type !== 'object') {
+        if (typeof schema.additionalItems !== 'boolean' && !isObject(schema.additionalItems)) {
             report.addError('KEYWORD_TYPE_EXPECTED', ['additionalItems', ['boolean', 'object']], undefined, schema, 'additionalItems');
         }
         else if (isObject(schema.additionalItems)) {
@@ -104,13 +118,7 @@ const SchemaValidators = {
     },
     items: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.1.1
-        const type = whatIs(schema.items);
-        if (type === 'object') {
-            report.path.push('items');
-            this.validateSchema(report, schema.items);
-            report.path.pop();
-        }
-        else if (Array.isArray(schema.items)) {
+        if (Array.isArray(schema.items)) {
             let idx = schema.items.length;
             while (idx--) {
                 report.path.push('items');
@@ -120,8 +128,13 @@ const SchemaValidators = {
                 report.path.pop();
             }
         }
+        else if (isObject(schema.items) || (report.options.version !== 'draft-04' && typeof schema.items === 'boolean')) {
+            report.path.push('items');
+            this.validateSchema(report, schema.items);
+            report.path.pop();
+        }
         else {
-            report.addError('KEYWORD_TYPE_EXPECTED', ['items', ['array', 'object']], undefined, schema, 'items');
+            report.addError('KEYWORD_TYPE_EXPECTED', ['items', report.options.version === 'draft-04' ? ['array', 'object'] : ['array', 'object', 'boolean']], undefined, schema, 'items');
         }
         // custom - strict mode
         if (this.options.forceAdditional === true && schema.additionalItems === undefined && Array.isArray(schema.items)) {
@@ -143,7 +156,7 @@ const SchemaValidators = {
     },
     minItems: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.3.1
-        if (whatIs(schema.minItems) !== 'integer') {
+        if (!isInteger(schema.minItems)) {
             report.addError('KEYWORD_TYPE_EXPECTED', ['minItems', 'integer'], undefined, schema, 'minItems');
         }
         else if (schema.minItems < 0) {
@@ -158,7 +171,7 @@ const SchemaValidators = {
     },
     maxProperties: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.1.1
-        if (whatIs(schema.maxProperties) !== 'integer') {
+        if (!isInteger(schema.maxProperties)) {
             report.addError('KEYWORD_TYPE_EXPECTED', ['maxProperties', 'integer'], undefined, schema, 'maxProperties');
         }
         else if (schema.maxProperties < 0) {
@@ -167,7 +180,7 @@ const SchemaValidators = {
     },
     minProperties: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.2.1
-        if (whatIs(schema.minProperties) !== 'integer') {
+        if (!isInteger(schema.minProperties)) {
             report.addError('KEYWORD_TYPE_EXPECTED', ['minProperties', 'integer'], undefined, schema, 'minProperties');
         }
         else if (schema.minProperties < 0) {
@@ -176,10 +189,10 @@ const SchemaValidators = {
     },
     required: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.3.1
-        if (whatIs(schema.required) !== 'array') {
+        if (!Array.isArray(schema.required)) {
             report.addError('KEYWORD_TYPE_EXPECTED', ['required', 'array'], undefined, schema, 'required');
         }
-        else if (schema.required.length === 0) {
+        else if (report.options.version === 'draft-04' && schema.required.length === 0) {
             report.addError('KEYWORD_MUST_BE', ['required', 'an array with at least one element'], undefined, schema, 'required');
         }
         else {
@@ -196,8 +209,7 @@ const SchemaValidators = {
     },
     additionalProperties: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.4.1
-        const type = whatIs(schema.additionalProperties);
-        if (type !== 'boolean' && type !== 'object') {
+        if (typeof schema.additionalProperties !== 'boolean' && !isObject(schema.additionalProperties)) {
             report.addError('KEYWORD_TYPE_EXPECTED', ['additionalProperties', ['boolean', 'object']], undefined, schema, 'additionalProperties');
         }
         else if (isObject(schema.additionalProperties)) {
@@ -208,7 +220,7 @@ const SchemaValidators = {
     },
     properties: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.4.1
-        if (whatIs(schema.properties) !== 'object') {
+        if (!isObject(schema.properties)) {
             report.addError('KEYWORD_TYPE_EXPECTED', ['properties', 'object'], undefined, schema, 'properties');
             return;
         }
@@ -238,7 +250,7 @@ const SchemaValidators = {
     },
     patternProperties: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.4.1
-        if (whatIs(schema.patternProperties) !== 'object') {
+        if (!isObject(schema.patternProperties)) {
             report.addError('KEYWORD_TYPE_EXPECTED', ['patternProperties', 'object'], undefined, schema, 'patternProperties');
             return;
         }
@@ -264,7 +276,7 @@ const SchemaValidators = {
     },
     dependencies: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.5.1
-        if (whatIs(schema.dependencies) !== 'object') {
+        if (!isObject(schema.dependencies)) {
             report.addError('KEYWORD_TYPE_EXPECTED', ['dependencies', 'object'], undefined, schema, 'dependencies');
         }
         else {
@@ -273,30 +285,32 @@ const SchemaValidators = {
             while (idx--) {
                 const schemaKey = keys[idx];
                 const schemaDependency = schema.dependencies[schemaKey];
-                const type = whatIs(schemaDependency);
-                if (type === 'object') {
+                const isSchemaDependency = isObject(schemaDependency) ||
+                    (report.options.version !== 'draft-04' && typeof schemaDependency === 'boolean');
+                if (isSchemaDependency) {
                     report.path.push('dependencies');
                     report.path.push(schemaKey);
                     this.validateSchema(report, schemaDependency);
                     report.path.pop();
                     report.path.pop();
                 }
-                else if (type === 'array') {
-                    let idx2 = schemaDependency.length;
-                    if (idx2 === 0) {
+                else if (Array.isArray(schemaDependency)) {
+                    const depArray = schemaDependency;
+                    let idx2 = depArray.length;
+                    if (report.options.version === 'draft-04' && idx2 === 0) {
                         report.addError('KEYWORD_MUST_BE', ['dependencies', 'not empty array'], undefined, schema, 'dependencies');
                     }
                     while (idx2--) {
-                        if (typeof schemaDependency[idx2] !== 'string') {
+                        if (typeof depArray[idx2] !== 'string') {
                             report.addError('KEYWORD_VALUE_TYPE', ['dependencies', 'string'], undefined, schema, 'dependencies');
                         }
                     }
-                    if (isUniqueArray(schemaDependency) === false) {
+                    if (isUniqueArray(depArray) === false) {
                         report.addError('KEYWORD_MUST_BE', ['dependencies', 'an array with unique items'], undefined, schema, 'dependencies');
                     }
                 }
                 else {
-                    report.addError('KEYWORD_VALUE_TYPE', ['dependencies', 'object or array'], undefined, schema, 'dependencies');
+                    report.addError('KEYWORD_VALUE_TYPE', ['dependencies', report.options.version === 'draft-04' ? 'object or array' : 'boolean, object or array'], undefined, schema, 'dependencies');
                 }
             }
         }
@@ -459,18 +473,22 @@ const SchemaValidators = {
     },
     not: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.6.1
-        if (whatIs(schema.not) !== 'object') {
-            report.addError('KEYWORD_TYPE_EXPECTED', ['not', 'object'], undefined, schema, 'not');
+        const notSchema = schema.not;
+        const isValidNotSchema = report.options.version === 'draft-04'
+            ? isObject(notSchema)
+            : typeof notSchema === 'boolean' || isObject(notSchema);
+        if (!isValidNotSchema) {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['not', report.options.version === 'draft-04' ? 'object' : ['boolean', 'object']], undefined, schema, 'not');
         }
         else {
             report.path.push('not');
-            this.validateSchema(report, schema.not);
+            this.validateSchema(report, notSchema);
             report.path.pop();
         }
     },
     definitions: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.7.1
-        if (whatIs(schema.definitions) !== 'object') {
+        if (!isObject(schema.definitions)) {
             report.addError('KEYWORD_TYPE_EXPECTED', ['definitions', 'object'], undefined, schema, 'definitions');
         }
         else {
@@ -540,12 +558,15 @@ export class SchemaValidator {
         if (Array.isArray(schema)) {
             return this.validateArrayOfSchemas(report, schema);
         }
+        if (typeof schema === 'boolean') {
+            return true;
+        }
         // 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;
+        const hasParentSchema = schema.$schema && getId(schema) !== schema.$schema;
         if (hasParentSchema) {
             if (schema.__$schemaResolved && schema.__$schemaResolved !== schema) {
                 const subReport = new Report(report);

package/dist/schemas/draft-06-hyper-schema.json

@@ -0,0 +1,132 @@
+{
+    "$schema": "http://json-schema.org/draft-06/hyper-schema#",
+    "$id": "http://json-schema.org/draft-06/hyper-schema#",
+    "title": "JSON Hyper-Schema",
+    "definitions": {
+        "schemaArray": {
+            "allOf": [
+                { "$ref": "http://json-schema.org/draft-06/schema#/definitions/schemaArray" },
+                {
+                    "items": { "$ref": "#" }
+                }
+            ]
+        },
+        "linkDescription": {
+            "title": "Link Description Object",
+            "type": "object",
+            "required": ["href"],
+            "properties": {
+                "href": {
+                    "description": "a URI template, as defined by RFC 6570",
+                    "type": "string",
+                    "format": "uri-template"
+                },
+                "hrefSchema": {
+                    "description": "a schema for validating user input to the URI template, where the input is in the form of a JSON object with property names matching variable names in \"href\"",
+                    "allOf": [{ "$ref": "#" }]
+                },
+                "rel": {
+                    "description": "relation to the target resource of the link",
+                    "type": "string"
+                },
+                "title": {
+                    "description": "a title for the link",
+                    "type": "string"
+                },
+                "targetSchema": {
+                    "description": "JSON Schema describing the link target",
+                    "allOf": [{ "$ref": "#" }]
+                },
+                "mediaType": {
+                    "description": "media type (as defined by RFC 2046) describing the link target",
+                    "type": "string"
+                },
+                "submissionEncType": {
+                    "description": "The media type in which to submit data along with the request",
+                    "type": "string",
+                    "default": "application/json"
+                },
+                "submissionSchema": {
+                    "description": "Schema describing the data to submit along with the request",
+                    "allOf": [{ "$ref": "#" }]
+                }
+            }
+        }
+    },
+    "allOf": [{ "$ref": "http://json-schema.org/draft-06/schema#" }],
+    "properties": {
+        "additionalItems": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ]
+        },
+        "additionalProperties": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ]
+        },
+        "dependencies": {
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "type": "array" }
+                ]
+            }
+        },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ]
+        },
+        "definitions": {
+            "additionalProperties": { "$ref": "#" }
+        },
+        "patternProperties": {
+            "additionalProperties": { "$ref": "#" }
+        },
+        "properties": {
+            "additionalProperties": { "$ref": "#" }
+        },
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" },
+        "contains": { "$ref": "#" },
+        "propertyNames": { "$ref": "#" },
+        "base": {
+            "description": "URI Template resolved as for the 'href' keyword in the Link Description Object.  The resulting URI Reference is resolved against the current URI base and sets the new URI base for URI references within the instance.",
+            "type": "string"
+        },
+        "links": {
+            "type": "array",
+            "items": { "$ref": "#/definitions/linkDescription" }
+        },
+        "media": {
+            "type": "object",
+            "properties": {
+                "type": {
+                    "description": "A media type, as described in RFC 2046",
+                    "type": "string"
+                },
+                "binaryEncoding": {
+                    "description": "A content encoding scheme, as described in RFC 2045",
+                    "type": "string"
+                }
+            }
+        },
+        "readOnly": {
+            "description": "If true, indicates that the value of this property is controlled by the server.",
+            "type": "boolean",
+            "default": false
+        }
+    },
+    "links": [
+        {
+            "rel": "self",
+            "href": "{+%24id}"
+        }
+    ]
+}

package/dist/schemas/draft-06-links.json

@@ -0,0 +1,43 @@
+{
+    "$schema": "http://json-schema.org/draft-06/hyper-schema#",
+    "$id": "http://json-schema.org/draft-06/links#",
+    "title": "Link Description Object",
+    "type": "object",
+    "required": ["href"],
+    "properties": {
+        "href": {
+            "description": "a URI template, as defined by RFC 6570",
+            "type": "string",
+            "format": "uri-template"
+        },
+        "hrefSchema": {
+            "description": "a schema for validating user input to the URI template, where the input is in the form of a JSON object with property names matching variable names in \"href\"",
+            "allOf": [{ "$ref": "#" }]
+        },
+        "rel": {
+            "description": "relation to the target resource of the link",
+            "type": "string"
+        },
+        "title": {
+            "description": "a title for the link",
+            "type": "string"
+        },
+        "targetSchema": {
+            "description": "JSON Schema describing the link target",
+            "allOf": [{ "$ref": "hyper-schema#" }]
+        },
+        "mediaType": {
+            "description": "media type (as defined by RFC 2046) describing the link target",
+            "type": "string"
+        },
+        "submissionEncType": {
+            "description": "The media type in which to submit data along with the request",
+            "type": "string",
+            "default": "application/json"
+        },
+        "submissionSchema": {
+            "description": "Schema describing the data to submit along with the request",
+            "allOf": [{ "$ref": "hyper-schema#" }]
+        }
+    }
+}

package/dist/schemas/draft-06-schema.json

@@ -0,0 +1,155 @@
+{
+    "$schema": "http://json-schema.org/draft-06/schema#",
+    "$id": "http://json-schema.org/draft-06/schema#",
+    "title": "Core schema meta-schema",
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#" }
+        },
+        "nonNegativeInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "nonNegativeIntegerDefault0": {
+            "allOf": [
+                { "$ref": "#/definitions/nonNegativeInteger" },
+                { "default": 0 }
+            ]
+        },
+        "simpleTypes": {
+            "enum": [
+                "array",
+                "boolean",
+                "integer",
+                "null",
+                "number",
+                "object",
+                "string"
+            ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "uniqueItems": true,
+            "default": []
+        }
+    },
+    "type": ["object", "boolean"],
+    "properties": {
+        "$id": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "$schema": {
+            "type": "string",
+            "format": "uri"
+        },
+        "$ref": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": {},
+        "examples": {
+            "type": "array",
+            "items": {}
+        },
+        "multipleOf": {
+            "type": "number",
+            "exclusiveMinimum": 0
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "number"
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "number"
+        },
+        "maxLength": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "additionalItems": { "$ref": "#" },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ],
+            "default": {}
+        },
+        "maxItems": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "contains": { "$ref": "#" },
+        "maxProperties": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "required": { "$ref": "#/definitions/stringArray" },
+        "additionalProperties": { "$ref": "#" },
+        "definitions": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "propertyNames": { "format": "regex" },
+            "default": {}
+        },
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/stringArray" }
+                ]
+            }
+        },
+        "propertyNames": { "$ref": "#" },
+        "const": {},
+        "enum": {
+            "type": "array",
+            "minItems": 1,
+            "uniqueItems": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "format": { "type": "string" },
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "default": {}
+}

package/dist/types/errors.d.ts

@@ -44,6 +44,10 @@ export declare const Errors: {
     ASYNC_TIMEOUT: string;
     PARENT_SCHEMA_VALIDATION_FAILED: string;
     REMOTE_NOT_VALID: string;
+    SCHEMA_IS_FALSE: string;
+    CONST: string;
+    CONTAINS: string;
+    PROPERTY_NAMES: string;
 };
 export declare class ValidateError extends Error {
     name: string;

package/dist/types/index.d.ts

@@ -3,7 +3,8 @@ export type { ErrorCode, ErrorParam, Errors } from './errors.js';
 export { ValidateError } from './errors.js';
 export type { FormatValidatorFn, FormatValidatorsOptions } from './format-validators.js';
 export { getFormatValidators, getRegisteredFormats, getSupportedFormats, isFormatSupported, registerFormat, unregisterFormat, } from './format-validators.js';
-export type { JsonSchema, JsonSchemaType } from './json-schema.js';
+export type { JsonSchemaType } from './json-schema.js';
+export type { JsonSchema } from './json-schema-versions.js';
 export type { Report, SchemaErrorDetail } from './report.js';
 export type { ZSchema, ZSchemaAsync, ZSchemaAsyncSafe, ZSchemaSafe } from './z-schema.js';
 export { ValidateOptions, ValidateResponse } from './z-schema-base.js';

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

@@ -0,0 +1,23 @@
+import type { JsonSchemaCommon, ZSchemaInternalProperties } from './json-schema.js';
+export type JsonSchemaVersion = 'draft-04' | 'draft-06';
+export declare const CURRENT_DEFAULT_SCHEMA_VERSION: JsonSchemaVersion;
+export declare const VERSION_SCHEMA_URL_MAPPING: Record<JsonSchemaVersion, string>;
+export type JsonSchema = JsonSchemaDraft4 | JsonSchemaDraft6;
+export type JsonSchemaAll = JsonSchemaDraft4 & JsonSchemaDraft6;
+export type JsonSchemaInternal = JsonSchema & ZSchemaInternalProperties;
+export type JsonSchemaInternalAll = JsonSchemaAll & ZSchemaInternalProperties;
+export type JsonSchemaInternalD4 = JsonSchemaDraft4 & ZSchemaInternalProperties;
+export type JsonSchemaInternalD6 = JsonSchemaDraft6 & ZSchemaInternalProperties;
+export interface JsonSchemaDraft4 extends JsonSchemaCommon {
+    exclusiveMaximum?: boolean;
+    exclusiveMinimum?: boolean;
+}
+export interface JsonSchemaDraft6 extends JsonSchemaCommon {
+    $id?: string;
+    examples?: unknown[];
+    const?: unknown;
+    contains?: JsonSchema;
+    propertyNames?: JsonSchema;
+    exclusiveMaximum?: number;
+    exclusiveMinimum?: number;
+}