z-schema 7.0.6 → 7.0.8

package/cjs/index.d.ts

@@ -54,7 +54,7 @@ interface Reference {
 declare class SchemaCompiler {
     private validator;
     constructor(validator: ZSchema);
-    compileSchema(report: Report, schema: JsonSchemaInternal): boolean;
+    compileSchema(report: Report, schema: JsonSchemaInternal | JsonSchemaInternal[]): boolean;
     compileArrayOfSchemas(report: Report, arr: JsonSchemaInternal[]): boolean;
     compileArrayOfSchemasLoop(mainReport: Report, arr: JsonSchemaInternal[]): number;
 }
@@ -107,7 +107,6 @@ interface ZSchemaInternalProperties {
 }
 interface JsonSchemaInternal extends JsonSchema, ZSchemaInternalProperties {
 }
-declare const findId: (schema: JsonSchemaInternal, id: string) => JsonSchemaInternal | undefined;
 
 interface SchemaError extends Error {
     /**
@@ -193,15 +192,6 @@ declare class Report {
 }
 
 type FormatValidatorFn = (input: unknown) => boolean;
-interface FormatValidatorsOptions {
-    strictUris?: boolean;
-}
-declare function getFormatValidators(options?: FormatValidatorsOptions): Record<string, FormatValidatorFn>;
-declare function registerFormat(name: string, validatorFunction: FormatValidatorFn): void;
-declare function unregisterFormat(name: string): void;
-declare function getSupportedFormats(): string[];
-declare function isFormatSupported(name: string): boolean;
-declare function getRegisteredFormats(): string[];
 
 type SchemaCacheStorage = Record<string, JsonSchemaInternal>;
 type ReferenceSchemaCacheStorage = Array<[JsonSchemaInternal, JsonSchemaInternal]>;
@@ -213,7 +203,9 @@ declare class SchemaCache {
     cacheSchemaByUri(uri: string, schema: JsonSchemaInternal): void;
     removeFromCacheByUri(uri: string): void;
     checkCacheForUri(uri: string): boolean;
-    getSchema(report: Report, refOrSchema: string | JsonSchemaInternal): JsonSchemaInternal | undefined;
+    getSchema(report: Report, refOrSchema: string): JsonSchemaInternal | undefined;
+    getSchema(report: Report, refOrSchema: JsonSchema): JsonSchemaInternal;
+    getSchema(report: Report, refOrSchema: JsonSchema[]): JsonSchemaInternal[];
     getSchemaByUri(report: Report, uri: string, root?: JsonSchemaInternal): JsonSchemaInternal | undefined;
     getSchemaByReference(report: Report, schema: JsonSchemaInternal): JsonSchemaInternal;
 }
@@ -268,10 +260,11 @@ declare class ZSchema {
     validateOptions: ValidateOptions;
     options: ZSchemaOptions;
     constructor(options?: ZSchemaOptions);
-    validateSchema(schema: JsonSchemaInternal): boolean;
-    validate(json: unknown, schema: JsonSchema, options?: ValidateOptions, callback?: ValidateCallback): void;
-    validate(json: unknown, schema: JsonSchema, callback?: ValidateCallback): void;
-    validate(json: unknown, schema: JsonSchema): boolean;
+    validateSchema(schemaOrArr: JsonSchema | JsonSchema[]): boolean;
+    validate(json: unknown, schema: JsonSchema | string, options: ValidateOptions, callback: ValidateCallback): void;
+    validate(json: unknown, schema: JsonSchema | string, callback: ValidateCallback): void;
+    validate(json: unknown, schema: JsonSchema | string, options: ValidateOptions): boolean;
+    validate(json: unknown, schema: JsonSchema | string): boolean;
     /**
      * Returns an Error object for the most recent failed validation, or null if the validation was successful.
      */
@@ -285,7 +278,7 @@ declare class ZSchema {
     compileSchema(schema: JsonSchema): boolean;
     getMissingReferences(arr?: SchemaErrorDetail[]): string[];
     getMissingRemoteReferences(): string[];
-    getResolvedSchema(schema: JsonSchemaInternal): JsonSchema;
+    getResolvedSchema(schema: JsonSchema): JsonSchema;
     static schemaReader: SchemaReader;
     setSchemaReader(schemaReader: SchemaReader): void;
     getSchemaReader(): SchemaReader;
@@ -294,9 +287,5 @@ declare class ZSchema {
     static jsonSymbol: symbol;
 }
 
-type JsonValidatorFn = (this: ZSchema, report: Report, schema: JsonSchemaInternal, json: unknown) => void;
-declare const JsonValidators: Record<keyof JsonSchema, JsonValidatorFn>;
-declare function validate(this: ZSchema, report: Report, schema: JsonSchemaInternal, json: unknown): boolean;
-
-export { Errors, JsonValidators, Report, SchemaCache, SchemaCompiler, SchemaValidator, ZSchema, ZSchema as default, findId, getFormatValidators, getRegisteredFormats, getSupportedFormats, isFormatSupported, registerFormat, unregisterFormat, validate };
-export type { ErrorCode, ErrorParam, FormatValidatorFn, FormatValidatorsOptions, JsonSchema, JsonSchemaInternal, JsonSchemaType, Reference, ReferenceSchemaCacheStorage, ReportOptions, SchemaCacheStorage, SchemaError, SchemaErrorDetail, ValidateCallback, ValidateOptions, ZSchemaInternalProperties, ZSchemaOptions };
+export { Errors, Report, ZSchema as default };
+export type { ErrorCode, ErrorParam, FormatValidatorFn, JsonSchema, JsonSchemaType, SchemaError, SchemaErrorDetail, SchemaReader, ValidateCallback, ValidateOptions, ZSchemaOptions };

package/cjs/index.js

@@ -12027,6 +12027,9 @@ class SchemaCache {
         return remotePath ? this.cache[remotePath] != null : false;
     }
     getSchema(report, refOrSchema) {
+        if (Array.isArray(refOrSchema)) {
+            return refOrSchema.map((i) => this.getSchema(report, i));
+        }
         if (typeof refOrSchema === 'string') {
             // ref input
             return this.getSchemaByUri(report, refOrSchema);
@@ -13511,15 +13514,24 @@ class ZSchema {
         this.setRemoteReference('http://json-schema.org/draft-04/schema', Draft4Schema, metaschemaOptions);
         this.setRemoteReference('http://json-schema.org/draft-04/hyper-schema', Draft4HyperSchema, metaschemaOptions);
     }
-    validateSchema(schema) {
-        if (Array.isArray(schema) && schema.length === 0) {
+    validateSchema(schemaOrArr) {
+        if (Array.isArray(schemaOrArr) && schemaOrArr.length === 0) {
             throw new Error('.validateSchema was called with an empty array');
         }
         const report = new Report(this.options);
-        schema = this.scache.getSchema(report, schema);
-        const compiled = this.sc.compileSchema(report, schema);
-        if (compiled) {
-            this.sv.validateSchema(report, schema);
+        if (Array.isArray(schemaOrArr)) {
+            const arr = this.scache.getSchema(report, schemaOrArr);
+            const compiled = this.sc.compileSchema(report, arr);
+            if (compiled) {
+                this.sv.validateSchema(report, arr);
+            }
+        }
+        else {
+            const schema = this.scache.getSchema(report, schemaOrArr);
+            const compiled = this.sc.compileSchema(report, schema);
+            if (compiled) {
+                this.sv.validateSchema(report, schema);
+            }
         }
         this.lastReport = report;
         return report.isValid();
@@ -13547,20 +13559,20 @@ class ZSchema {
         let foundError = false;
         const report = new Report(this.options);
         report.json = json;
+        let _schema;
         if (typeof schema === 'string') {
             const schemaName = schema;
-            const _schema = this.scache.getSchema(report, schemaName);
+            _schema = this.scache.getSchema(report, schemaName);
             if (!_schema) {
                 throw new Error("Schema with id '" + schemaName + "' wasn't found in the validator cache!");
             }
-            schema = _schema;
         }
         else {
-            schema = this.scache.getSchema(report, schema);
+            _schema = this.scache.getSchema(report, schema);
         }
         let compiled = false;
         if (!foundError) {
-            compiled = this.sc.compileSchema(report, schema);
+            compiled = this.sc.compileSchema(report, _schema);
         }
         if (!compiled) {
             this.lastReport = report;
@@ -13568,21 +13580,21 @@ class ZSchema {
         }
         let validated = false;
         if (!foundError) {
-            validated = this.sv.validateSchema(report, schema);
+            validated = this.sv.validateSchema(report, _schema);
         }
         if (!validated) {
             this.lastReport = report;
             foundError = true;
         }
         if (options.schemaPath) {
-            report.rootSchema = schema;
-            schema = get(schema, options.schemaPath);
-            if (!schema) {
+            report.rootSchema = _schema;
+            _schema = get(_schema, options.schemaPath);
+            if (!_schema) {
                 throw new Error("Schema path '" + options.schemaPath + "' wasn't found in the schema!");
             }
         }
         if (!foundError) {
-            validate.call(this, report, schema, json);
+            validate.call(this, report, _schema, json);
         }
         if (callback) {
             report.processAsyncTasks(this.options.asyncTimeout, callback);

package/dist/schema-cache.js

@@ -28,6 +28,9 @@ export class SchemaCache {
         return remotePath ? this.cache[remotePath] != null : false;
     }
     getSchema(report, refOrSchema) {
+        if (Array.isArray(refOrSchema)) {
+            return refOrSchema.map((i) => this.getSchema(report, i));
+        }
         if (typeof refOrSchema === 'string') {
             // ref input
             return this.getSchemaByUri(report, refOrSchema);

package/dist/types/index.d.ts

@@ -1,11 +1,7 @@
 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 type { FormatValidatorFn } from './format-validators.js';
+export type { ErrorCode, ErrorParam, Errors } from './errors.js';
+export type { JsonSchema, JsonSchemaType } from './json-schema.js';
+export type { Report, SchemaError, SchemaErrorDetail } from './report.js';
+export type { ZSchemaOptions, SchemaReader, ValidateOptions, ValidateCallback } from './z-schema.js';
 export default ZSchema;

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

@@ -1,7 +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;
+type JsonValidatorFn = (this: ZSchema, report: Report, schema: JsonSchema, 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 {};

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

@@ -1,6 +1,6 @@
 import type { ZSchema } from './z-schema.js';
 import { Report } from './report.js';
-import { JsonSchemaInternal } from './json-schema.js';
+import { JsonSchema, JsonSchemaInternal } from './json-schema.js';
 export type SchemaCacheStorage = Record<string, JsonSchemaInternal>;
 export type ReferenceSchemaCacheStorage = Array<[JsonSchemaInternal, JsonSchemaInternal]>;
 export declare class SchemaCache {
@@ -11,7 +11,9 @@ export declare class SchemaCache {
     cacheSchemaByUri(uri: string, schema: JsonSchemaInternal): void;
     removeFromCacheByUri(uri: string): void;
     checkCacheForUri(uri: string): boolean;
-    getSchema(report: Report, refOrSchema: string | JsonSchemaInternal): JsonSchemaInternal | undefined;
+    getSchema(report: Report, refOrSchema: string): JsonSchemaInternal | undefined;
+    getSchema(report: Report, refOrSchema: JsonSchema): JsonSchemaInternal;
+    getSchema(report: Report, refOrSchema: JsonSchema[]): JsonSchemaInternal[];
     getSchemaByUri(report: Report, uri: string, root?: JsonSchemaInternal): JsonSchemaInternal | undefined;
     getSchemaByReference(report: Report, schema: JsonSchemaInternal): JsonSchemaInternal;
 }

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

@@ -10,7 +10,7 @@ export interface Reference {
 export declare class SchemaCompiler {
     private validator;
     constructor(validator: ZSchema);
-    compileSchema(report: Report, schema: JsonSchemaInternal): boolean;
+    compileSchema(report: Report, schema: JsonSchemaInternal | JsonSchemaInternal[]): boolean;
     compileArrayOfSchemas(report: Report, arr: JsonSchemaInternal[]): boolean;
     compileArrayOfSchemasLoop(mainReport: Report, arr: JsonSchemaInternal[]): number;
 }

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

@@ -4,7 +4,7 @@ import { SchemaCache } from './schema-cache.js';
 import { SchemaCompiler } from './schema-compiler.js';
 import { SchemaValidator } from './schema-validator.js';
 import type { Errors } from './errors.js';
-import type { JsonSchema, JsonSchemaInternal } from './json-schema.js';
+import type { JsonSchema } from './json-schema.js';
 export interface ZSchemaOptions {
     asyncTimeout?: number;
     forceAdditional?: boolean;
@@ -34,7 +34,7 @@ export interface ValidateOptions {
     includeErrors?: Array<keyof typeof Errors>;
 }
 export type ValidateCallback = (e: Error | SchemaErrorDetail[] | null, valid: boolean) => void;
-type SchemaReader = (uri: string) => JsonSchema;
+export type SchemaReader = (uri: string) => JsonSchema;
 export declare class ZSchema {
     static registerFormat(name: string, validatorFunction: FormatValidatorFn): void;
     static unregisterFormat(name: string): void;
@@ -47,10 +47,11 @@ export declare class ZSchema {
     validateOptions: ValidateOptions;
     options: ZSchemaOptions;
     constructor(options?: ZSchemaOptions);
-    validateSchema(schema: JsonSchemaInternal): boolean;
-    validate(json: unknown, schema: JsonSchema, options?: ValidateOptions, callback?: ValidateCallback): void;
-    validate(json: unknown, schema: JsonSchema, callback?: ValidateCallback): void;
-    validate(json: unknown, schema: JsonSchema): boolean;
+    validateSchema(schemaOrArr: JsonSchema | JsonSchema[]): boolean;
+    validate(json: unknown, schema: JsonSchema | string, options: ValidateOptions, callback: ValidateCallback): void;
+    validate(json: unknown, schema: JsonSchema | string, callback: ValidateCallback): void;
+    validate(json: unknown, schema: JsonSchema | string, options: ValidateOptions): boolean;
+    validate(json: unknown, schema: JsonSchema | string): boolean;
     /**
      * Returns an Error object for the most recent failed validation, or null if the validation was successful.
      */
@@ -64,7 +65,7 @@ export declare class ZSchema {
     compileSchema(schema: JsonSchema): boolean;
     getMissingReferences(arr?: SchemaErrorDetail[]): string[];
     getMissingRemoteReferences(): string[];
-    getResolvedSchema(schema: JsonSchemaInternal): JsonSchema;
+    getResolvedSchema(schema: JsonSchema): JsonSchema;
     static schemaReader: SchemaReader;
     setSchemaReader(schemaReader: SchemaReader): void;
     getSchemaReader(): SchemaReader;
@@ -72,4 +73,3 @@ export declare class ZSchema {
     static schemaSymbol: symbol;
     static jsonSymbol: symbol;
 }
-export {};

package/dist/z-schema.js

@@ -131,15 +131,24 @@ export class ZSchema {
         this.setRemoteReference('http://json-schema.org/draft-04/schema', Draft4Schema, metaschemaOptions);
         this.setRemoteReference('http://json-schema.org/draft-04/hyper-schema', Draft4HyperSchema, metaschemaOptions);
     }
-    validateSchema(schema) {
-        if (Array.isArray(schema) && schema.length === 0) {
+    validateSchema(schemaOrArr) {
+        if (Array.isArray(schemaOrArr) && schemaOrArr.length === 0) {
             throw new Error('.validateSchema was called with an empty array');
         }
         const report = new Report(this.options);
-        schema = this.scache.getSchema(report, schema);
-        const compiled = this.sc.compileSchema(report, schema);
-        if (compiled) {
-            this.sv.validateSchema(report, schema);
+        if (Array.isArray(schemaOrArr)) {
+            const arr = this.scache.getSchema(report, schemaOrArr);
+            const compiled = this.sc.compileSchema(report, arr);
+            if (compiled) {
+                this.sv.validateSchema(report, arr);
+            }
+        }
+        else {
+            const schema = this.scache.getSchema(report, schemaOrArr);
+            const compiled = this.sc.compileSchema(report, schema);
+            if (compiled) {
+                this.sv.validateSchema(report, schema);
+            }
         }
         this.lastReport = report;
         return report.isValid();
@@ -167,20 +176,20 @@ export class ZSchema {
         let foundError = false;
         const report = new Report(this.options);
         report.json = json;
+        let _schema;
         if (typeof schema === 'string') {
             const schemaName = schema;
-            const _schema = this.scache.getSchema(report, schemaName);
+            _schema = this.scache.getSchema(report, schemaName);
             if (!_schema) {
                 throw new Error("Schema with id '" + schemaName + "' wasn't found in the validator cache!");
             }
-            schema = _schema;
         }
         else {
-            schema = this.scache.getSchema(report, schema);
+            _schema = this.scache.getSchema(report, schema);
         }
         let compiled = false;
         if (!foundError) {
-            compiled = this.sc.compileSchema(report, schema);
+            compiled = this.sc.compileSchema(report, _schema);
         }
         if (!compiled) {
             this.lastReport = report;
@@ -188,21 +197,21 @@ export class ZSchema {
         }
         let validated = false;
         if (!foundError) {
-            validated = this.sv.validateSchema(report, schema);
+            validated = this.sv.validateSchema(report, _schema);
         }
         if (!validated) {
             this.lastReport = report;
             foundError = true;
         }
         if (options.schemaPath) {
-            report.rootSchema = schema;
-            schema = get(schema, options.schemaPath);
-            if (!schema) {
+            report.rootSchema = _schema;
+            _schema = get(_schema, options.schemaPath);
+            if (!_schema) {
                 throw new Error("Schema path '" + options.schemaPath + "' wasn't found in the schema!");
             }
         }
         if (!foundError) {
-            validateJson.call(this, report, schema, json);
+            validateJson.call(this, report, _schema, json);
         }
         if (callback) {
             report.processAsyncTasks(this.options.asyncTimeout, callback);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "z-schema",
-  "version": "7.0.6",
+  "version": "7.0.8",
   "engines": {
     "node": ">=22.0.0"
   },

package/src/index.ts

@@ -1,14 +1,10 @@
 import { ZSchema } from './z-schema.js';
 
 // Export types and interfaces from relevant files
-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 type { FormatValidatorFn } from './format-validators.js';
+export type { ErrorCode, ErrorParam, Errors } from './errors.js';
+export type { JsonSchema, JsonSchemaType } from './json-schema.js';
+export type { Report, SchemaError, SchemaErrorDetail } from './report.js';
+export type { ZSchemaOptions, SchemaReader, ValidateOptions, ValidateCallback } from './z-schema.js';
 
 export default ZSchema;

package/src/json-validation.ts

@@ -19,7 +19,7 @@ const shouldSkipValidate = function (options: ValidateOptions, errors: any) {
   );
 };
 
-type JsonValidatorFn = (this: ZSchema, report: Report, schema: JsonSchemaInternal, json: unknown) => void;
+type JsonValidatorFn = (this: ZSchema, report: Report, schema: JsonSchema, json: unknown) => void;
 
 export const JsonValidators: Record<keyof JsonSchema, JsonValidatorFn> = {
   id: () => {},

package/src/schema-cache.ts

@@ -1,7 +1,7 @@
 import type { ZSchema } from './z-schema.js';
 import isequal from 'lodash.isequal';
 import { Report } from './report.js';
-import { findId, JsonSchemaInternal } from './json-schema.js';
+import { findId, JsonSchema, JsonSchemaInternal } from './json-schema.js';
 import { getQueryPath, getRemotePath } from './utils/uri.js';
 import { deepClone } from './utils/clone.js';
 import { decodeJSONPointer } from './utils/json.js';
@@ -34,7 +34,13 @@ export class SchemaCache {
     return remotePath ? this.cache[remotePath] != null : false;
   }
 
-  getSchema(report: Report, refOrSchema: string | JsonSchemaInternal) {
+  getSchema(report: Report, refOrSchema: string): JsonSchemaInternal | undefined;
+  getSchema(report: Report, refOrSchema: JsonSchema): JsonSchemaInternal;
+  getSchema(report: Report, refOrSchema: JsonSchema[]): JsonSchemaInternal[];
+  getSchema(report: Report, refOrSchema: string | JsonSchema | JsonSchema[]) {
+    if (Array.isArray(refOrSchema)) {
+      return refOrSchema.map((i) => this.getSchema(report, i));
+    }
     if (typeof refOrSchema === 'string') {
       // ref input
       return this.getSchemaByUri(report, refOrSchema);

package/src/schema-compiler.ts

@@ -107,7 +107,7 @@ const mergeReference = (scope: string[], ref: string) => {
 export class SchemaCompiler {
   constructor(private validator: ZSchema) {}
 
-  compileSchema(report: Report, schema: JsonSchemaInternal) {
+  compileSchema(report: Report, schema: JsonSchemaInternal | JsonSchemaInternal[]) {
     report.commonErrorMessage = 'SCHEMA_COMPILATION_FAILED';
 
     // if schema is a string, assume it's a uri

package/src/z-schema.ts

@@ -147,7 +147,7 @@ export interface ValidateOptions {
 export type ValidateCallback = (e: Error | SchemaErrorDetail[] | null, valid: boolean) => void;
 
 // a sync function that loads schemas for future use, for example from schemas directory, during server startup
-type SchemaReader = (uri: string) => JsonSchema;
+export type SchemaReader = (uri: string) => JsonSchema;
 
 export class ZSchema {
   public static registerFormat(name: string, validatorFunction: FormatValidatorFn): void {
@@ -186,30 +186,38 @@ export class ZSchema {
     this.setRemoteReference('http://json-schema.org/draft-04/hyper-schema', Draft4HyperSchema, metaschemaOptions);
   }
 
-  validateSchema(schema: JsonSchemaInternal): boolean {
-    if (Array.isArray(schema) && schema.length === 0) {
+  validateSchema(schemaOrArr: JsonSchema | JsonSchema[]): boolean {
+    if (Array.isArray(schemaOrArr) && schemaOrArr.length === 0) {
       throw new Error('.validateSchema was called with an empty array');
     }
 
     const report = new Report(this.options);
 
-    schema = this.scache.getSchema(report, schema)!;
-
-    const compiled = this.sc.compileSchema(report, schema);
-    if (compiled) {
-      this.sv.validateSchema(report, schema);
+    if (Array.isArray(schemaOrArr)) {
+      const arr = this.scache.getSchema(report, schemaOrArr)!;
+      const compiled = this.sc.compileSchema(report, arr);
+      if (compiled) {
+        this.sv.validateSchema(report, arr);
+      }
+    } else {
+      const schema = this.scache.getSchema(report, schemaOrArr)!;
+      const compiled = this.sc.compileSchema(report, schema);
+      if (compiled) {
+        this.sv.validateSchema(report, schema);
+      }
     }
 
     this.lastReport = report;
     return report.isValid();
   }
 
-  validate(json: unknown, schema: JsonSchema, options?: ValidateOptions, callback?: ValidateCallback): void;
-  validate(json: unknown, schema: JsonSchema, callback?: ValidateCallback): void;
-  validate(json: unknown, schema: JsonSchema): boolean;
+  validate(json: unknown, schema: JsonSchema | string, options: ValidateOptions, callback: ValidateCallback): void;
+  validate(json: unknown, schema: JsonSchema | string, callback: ValidateCallback): void;
+  validate(json: unknown, schema: JsonSchema | string, options: ValidateOptions): boolean;
+  validate(json: unknown, schema: JsonSchema | string): boolean;
   validate(
     json: unknown,
-    schema: JsonSchema,
+    schema: JsonSchema | string,
     options?: ValidateOptions | ValidateCallback,
     callback?: ValidateCallback
   ): boolean | void {
@@ -241,20 +249,20 @@ export class ZSchema {
     const report = new Report(this.options);
     report.json = json;
 
+    let _schema: JsonSchemaInternal;
     if (typeof schema === 'string') {
       const schemaName = schema;
-      const _schema = this.scache.getSchema(report, schemaName);
+      _schema = this.scache.getSchema(report, schemaName)!;
       if (!_schema) {
         throw new Error("Schema with id '" + schemaName + "' wasn't found in the validator cache!");
       }
-      schema = _schema;
     } else {
-      schema = this.scache.getSchema(report, schema)!;
+      _schema = this.scache.getSchema(report, schema)!;
     }
 
     let compiled = false;
     if (!foundError) {
-      compiled = this.sc.compileSchema(report, schema);
+      compiled = this.sc.compileSchema(report, _schema);
     }
     if (!compiled) {
       this.lastReport = report;
@@ -263,7 +271,7 @@ export class ZSchema {
 
     let validated = false;
     if (!foundError) {
-      validated = this.sv.validateSchema(report, schema);
+      validated = this.sv.validateSchema(report, _schema);
     }
     if (!validated) {
       this.lastReport = report;
@@ -271,15 +279,15 @@ export class ZSchema {
     }
 
     if (options.schemaPath) {
-      report.rootSchema = schema;
-      schema = get(schema, options.schemaPath);
-      if (!schema) {
+      report.rootSchema = _schema;
+      _schema = get(_schema, options.schemaPath);
+      if (!_schema) {
         throw new Error("Schema path '" + options.schemaPath + "' wasn't found in the schema!");
       }
     }
 
     if (!foundError) {
-      validateJson.call(this, report, schema, json);
+      validateJson.call(this, report, _schema, json);
     }
 
     if (callback) {
@@ -380,7 +388,7 @@ export class ZSchema {
     return missingRemoteReferences;
   }
 
-  getResolvedSchema(schema: JsonSchemaInternal): JsonSchema {
+  getResolvedSchema(schema: JsonSchema): JsonSchema {
     const report = new Report(this.options);
     schema = this.scache.getSchema(report, schema)!;