z-schema 7.0.0 → 7.0.6

package/src/{SchemaValidation.ts → schema-validator.ts}

@@ -1,23 +1,27 @@
-import { FormatValidators } from './FormatValidators.js';
-import * as JsonValidation from './JsonValidation.js';
-import { Report } from './Report.js';
-import * as Utils from './Utils.js';
+import type { ZSchema } from './z-schema.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 { JsonSchema, JsonSchemaInternal } from './json-schema.js';
+import { isUniqueArray } from './utils/array.js';
+import { isFormatSupported } from './format-validators.js';
 
 const SchemaValidators = {
-  $ref: function (report, schema) {
+  $ref: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-07
     // http://tools.ietf.org/html/draft-pbryan-zyp-json-ref-03
     if (typeof schema.$ref !== 'string') {
       report.addError('KEYWORD_TYPE_EXPECTED', ['$ref', 'string']);
     }
   },
-  $schema: function (report, schema) {
+  $schema: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-core.html#rfc.section.6
     if (typeof schema.$schema !== 'string') {
       report.addError('KEYWORD_TYPE_EXPECTED', ['$schema', 'string']);
     }
   },
-  multipleOf: function (report, schema) {
+  multipleOf: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.1.1
     if (typeof schema.multipleOf !== 'number') {
       report.addError('KEYWORD_TYPE_EXPECTED', ['multipleOf', 'number']);
@@ -25,13 +29,13 @@ const SchemaValidators = {
       report.addError('KEYWORD_MUST_BE', ['multipleOf', 'strictly greater than 0']);
     }
   },
-  maximum: function (report, schema) {
+  maximum: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.2.1
     if (typeof schema.maximum !== 'number') {
       report.addError('KEYWORD_TYPE_EXPECTED', ['maximum', 'number']);
     }
   },
-  exclusiveMaximum: function (report, schema) {
+  exclusiveMaximum: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // 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']);
@@ -39,13 +43,13 @@ const SchemaValidators = {
       report.addError('KEYWORD_DEPENDENCY', ['exclusiveMaximum', 'maximum']);
     }
   },
-  minimum: function (report, schema) {
+  minimum: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.3.1
     if (typeof schema.minimum !== 'number') {
       report.addError('KEYWORD_TYPE_EXPECTED', ['minimum', 'number']);
     }
   },
-  exclusiveMinimum: function (report, schema) {
+  exclusiveMinimum: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // 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']);
@@ -53,23 +57,23 @@ const SchemaValidators = {
       report.addError('KEYWORD_DEPENDENCY', ['exclusiveMinimum', 'minimum']);
     }
   },
-  maxLength: function (report, schema) {
+  maxLength: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // 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) {
+    } else if (schema.maxLength! < 0) {
       report.addError('KEYWORD_MUST_BE', ['maxLength', 'greater than, or equal to 0']);
     }
   },
-  minLength: function (report, schema) {
+  minLength: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // 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) {
+    } else if (schema.minLength! < 0) {
       report.addError('KEYWORD_MUST_BE', ['minLength', 'greater than, or equal to 0']);
     }
   },
-  pattern: function (report, schema) {
+  pattern: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.3.1
     if (typeof schema.pattern !== 'string') {
       report.addError('KEYWORD_TYPE_EXPECTED', ['pattern', 'string']);
@@ -81,31 +85,30 @@ const SchemaValidators = {
       }
     }
   },
-  additionalItems: function (report, schema) {
+  additionalItems: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // 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) {
+  items: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // 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();
       }
@@ -122,7 +125,7 @@ const SchemaValidators = {
       schema.additionalItems = false;
     }
   },
-  maxItems: function (report, schema) {
+  maxItems: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.2.1
     if (typeof schema.maxItems !== 'number') {
       report.addError('KEYWORD_TYPE_EXPECTED', ['maxItems', 'integer']);
@@ -130,80 +133,80 @@ const SchemaValidators = {
       report.addError('KEYWORD_MUST_BE', ['maxItems', 'greater than, or equal to 0']);
     }
   },
-  minItems: function (report, schema) {
+  minItems: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // 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) {
+    } else if (schema.minItems! < 0) {
       report.addError('KEYWORD_MUST_BE', ['minItems', 'greater than, or equal to 0']);
     }
   },
-  uniqueItems: function (report, schema) {
+  uniqueItems: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.4.1
     if (typeof schema.uniqueItems !== 'boolean') {
       report.addError('KEYWORD_TYPE_EXPECTED', ['uniqueItems', 'boolean']);
     }
   },
-  maxProperties: function (report, schema) {
+  maxProperties: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // 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) {
+    } else if (schema.maxProperties! < 0) {
       report.addError('KEYWORD_MUST_BE', ['maxProperties', 'greater than, or equal to 0']);
     }
   },
-  minProperties: function (report, schema) {
+  minProperties: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // 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) {
+    } else if (schema.minProperties! < 0) {
       report.addError('KEYWORD_MUST_BE', ['minProperties', 'greater than, or equal to 0']);
     }
   },
-  required: function (report, schema) {
+  required: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // 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) {
+    } else if (schema.required!.length === 0) {
       report.addError('KEYWORD_MUST_BE', ['required', 'an array with at least one element']);
     } else {
-      let idx = schema.required.length;
+      let idx = schema.required!.length;
       while (idx--) {
-        if (typeof schema.required[idx] !== 'string') {
+        if (typeof schema.required![idx] !== 'string') {
           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) {
+  additionalProperties: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // 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) {
+  properties: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // 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);
+    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();
     }
@@ -221,26 +224,26 @@ const SchemaValidators = {
       report.addError('CUSTOM_MODE_FORCE_PROPERTIES', ['properties']);
     }
   },
-  patternProperties: function (report, schema) {
+  patternProperties: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // 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;
     }
 
-    const keys = Object.keys(schema.patternProperties);
+    const keys = Object.keys(schema.patternProperties!);
     let idx = keys.length;
     while (idx--) {
       const key = keys[idx],
-        val = schema.patternProperties[key];
+        val = schema.patternProperties![key];
       try {
         RegExp(key);
       } catch (_e) {
         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();
     }
@@ -250,22 +253,21 @@ const SchemaValidators = {
       report.addError('CUSTOM_MODE_FORCE_PROPERTIES', ['patternProperties']);
     }
   },
-  dependencies: function (report, schema) {
+  dependencies: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // 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);
+      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 as any);
           report.path.pop();
           report.path.pop();
         } else if (type === 'array') {
@@ -278,7 +280,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']);
           }
         } else {
@@ -287,30 +289,30 @@ const SchemaValidators = {
       }
     }
   },
-  enum: function (report, schema) {
+  enum: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.1.1
     if (Array.isArray(schema.enum) === false) {
       report.addError('KEYWORD_TYPE_EXPECTED', ['enum', 'array']);
     } 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) {
+  type: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // 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);
+    const primitiveTypes = ['array', 'boolean', 'integer', 'number', 'null', 'object', 'string'];
+    const primitiveTypeStr = primitiveTypes.join(',');
+    const isArray = Array.isArray(schema.type);
 
-    if (isArray) {
+    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']);
       }
     } else if (typeof schema.type === 'string') {
@@ -322,49 +324,49 @@ const SchemaValidators = {
     }
 
     if (this.options.noEmptyStrings === true) {
-      if (schema.type === 'string' || (isArray && schema.type.indexOf('string') !== -1)) {
+      if (schema.type === 'string' || (isArray && schema.type!.indexOf('string') !== -1)) {
         if (schema.minLength === undefined && schema.enum === undefined && schema.format === undefined) {
           schema.minLength = 1;
         }
       }
     }
     if (this.options.noEmptyArrays === true) {
-      if (schema.type === 'array' || (isArray && schema.type.indexOf('array') !== -1)) {
+      if (schema.type === 'array' || (isArray && schema.type!.indexOf('array') !== -1)) {
         if (schema.minItems === undefined) {
           schema.minItems = 1;
         }
       }
     }
     if (this.options.forceProperties === true) {
-      if (schema.type === 'object' || (isArray && schema.type.indexOf('object') !== -1)) {
+      if (schema.type === 'object' || (isArray && schema.type!.indexOf('object') !== -1)) {
         if (schema.properties === undefined && schema.patternProperties === undefined) {
           report.addError('KEYWORD_UNDEFINED_STRICT', ['properties']);
         }
       }
     }
     if (this.options.forceItems === true) {
-      if (schema.type === 'array' || (isArray && schema.type.indexOf('array') !== -1)) {
+      if (schema.type === 'array' || (isArray && schema.type!.indexOf('array') !== -1)) {
         if (schema.items === undefined) {
           report.addError('KEYWORD_UNDEFINED_STRICT', ['items']);
         }
       }
     }
     if (this.options.forceMinItems === true) {
-      if (schema.type === 'array' || (isArray && schema.type.indexOf('array') !== -1)) {
+      if (schema.type === 'array' || (isArray && schema.type!.indexOf('array') !== -1)) {
         if (schema.minItems === undefined) {
           report.addError('KEYWORD_UNDEFINED_STRICT', ['minItems']);
         }
       }
     }
     if (this.options.forceMaxItems === true) {
-      if (schema.type === 'array' || (isArray && schema.type.indexOf('array') !== -1)) {
+      if (schema.type === 'array' || (isArray && schema.type!.indexOf('array') !== -1)) {
         if (schema.maxItems === undefined) {
           report.addError('KEYWORD_UNDEFINED_STRICT', ['maxItems']);
         }
       }
     }
     if (this.options.forceMinLength === true) {
-      if (schema.type === 'string' || (isArray && schema.type.indexOf('string') !== -1)) {
+      if (schema.type === 'string' || (isArray && schema.type!.indexOf('string') !== -1)) {
         if (
           schema.minLength === undefined &&
           schema.format === undefined &&
@@ -376,7 +378,7 @@ const SchemaValidators = {
       }
     }
     if (this.options.forceMaxLength === true) {
-      if (schema.type === 'string' || (isArray && schema.type.indexOf('string') !== -1)) {
+      if (schema.type === 'string' || (isArray && schema.type!.indexOf('string') !== -1)) {
         if (
           schema.maxLength === undefined &&
           schema.format === undefined &&
@@ -388,7 +390,7 @@ const SchemaValidators = {
       }
     }
   },
-  allOf: function (report, schema) {
+  allOf: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.3.1
     if (Array.isArray(schema.allOf) === false) {
       report.addError('KEYWORD_TYPE_EXPECTED', ['allOf', 'array']);
@@ -398,14 +400,14 @@ 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();
       }
     }
   },
-  anyOf: function (report, schema) {
+  anyOf: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.4.1
     if (Array.isArray(schema.anyOf) === false) {
       report.addError('KEYWORD_TYPE_EXPECTED', ['anyOf', 'array']);
@@ -415,14 +417,14 @@ 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();
       }
     }
   },
-  oneOf: function (report, schema) {
+  oneOf: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.5.1
     if (Array.isArray(schema.oneOf) === false) {
       report.addError('KEYWORD_TYPE_EXPECTED', ['oneOf', 'array']);
@@ -432,198 +434,194 @@ 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();
       }
     }
   },
-  not: function (report, schema) {
+  not: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // 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) {
+  definitions: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // 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 {
-      const keys = Object.keys(schema.definitions);
+      const keys = Object.keys(schema.definitions!);
       let idx = keys.length;
       while (idx--) {
         const key = keys[idx],
-          val = schema.definitions[key];
+          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();
       }
     }
   },
-  format: function (report, schema) {
+  format: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     if (typeof schema.format !== 'string') {
       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]);
       }
     }
   },
-  id: function (report, schema) {
+  id: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-core.html#rfc.section.7.2
     if (typeof schema.id !== 'string') {
       report.addError('KEYWORD_TYPE_EXPECTED', ['id', 'string']);
     }
   },
-  title: function (report, schema) {
+  title: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.6.1
     if (typeof schema.title !== 'string') {
       report.addError('KEYWORD_TYPE_EXPECTED', ['title', 'string']);
     }
   },
-  description: function (report, schema) {
+  description: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.6.1
     if (typeof schema.description !== 'string') {
       report.addError('KEYWORD_TYPE_EXPECTED', ['description', 'string']);
     }
   },
-  default: function (/* report, schema */) {
+  default: function (this: SchemaValidator /* report, schema */) {
     // 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]);
-  }
-  return report.isValid();
-};
+} as const;
 
-/**
- *
- * @param {Report} report
- * @param {*} schema
- */
-export function validateSchema(report, schema) {
-  report.commonErrorMessage = 'SCHEMA_VALIDATION_FAILED';
+export class SchemaValidator {
+  constructor(private validator: ZSchema) {}
 
-  // 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: Report, arr: JsonSchemaInternal[]) {
+    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);
-      }
-    } else {
-      if (this.options.ignoreUnresolvableReferences !== true) {
-        report.addError('REF_UNRESOLVED', [schema.$schema]);
-      }
+  validateSchema(report: Report, schema: JsonSchemaInternal | JsonSchemaInternal[]) {
+    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 (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 $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.validator.options.ignoreUnresolvableReferences !== true) {
+          report.addError('REF_UNRESOLVED', [schema.$schema!]);
+        }
       }
-      if (Array.isArray(schema.oneOf)) {
-        schemas = schemas.concat(schema.oneOf);
+    }
+
+    if (this.validator.options.noTypeless === true) {
+      // issue #36 - inherit type to anyOf, oneOf, allOf if noTypeless is defined
+      if (schema.type !== undefined) {
+        let schemas: JsonSchema[] = [];
+        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 (Array.isArray(schema.allOf)) {
-        schemas = schemas.concat(schema.allOf);
+      // 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']);
       }
-      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']);
     }
-  }
 
-  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);
-    } 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 as keyof typeof SchemaValidators].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;
+    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.toString());
-        JsonValidation.validate.call(this, report, tmpSchema, schema.enum[idx]);
+        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();
       }
-      report.path.pop();
-    }
 
-    if (schema.default) {
-      report.path.push('default');
-      JsonValidation.validate.call(this, report, schema, schema.default);
-      report.path.pop();
+      if (schema.default) {
+        report.path.push('default');
+        validate.call(this.validator, report, schema, schema.default);
+        report.path.pop();
+      }
     }
-  }
 
-  const isValid = report.isValid();
-  if (isValid) {
-    schema.__$validated = true;
+    const isValid = report.isValid();
+    if (isValid) {
+      schema.__$validated = true;
+    }
+    return isValid;
   }
-  return isValid;
 }