z-schema 12.1.1 → 12.3.1

package/dist/validation/{string.mjs → string.js}

@@ -1,22 +1,22 @@
-import { whatIs } from "../utils/what-is.mjs";
-import { getFormatValidators } from "../format-validators.mjs";
-import { compileSchemaRegex } from "../utils/schema-regex.mjs";
-import { isFormatAssertionVocabEnabled, shouldSkipValidate } from "./shared.mjs";
-import { decodeBase64, isValidBase64 } from "../utils/base64.mjs";
-import { unicodeLength } from "../utils/unicode.mjs";
+import { whatIs } from "../utils/what-is.js";
+import { resolveFormatValidator } from "../format-validators.js";
+import { compileSchemaRegex } from "../utils/schema-regex.js";
+import { isFormatAssertionVocabEnabled, shouldSkipValidate } from "./shared.js";
+import { decodeBase64, isValidBase64 } from "../utils/base64.js";
+import { unicodeLength } from "../utils/unicode.js";
 //#region src/validation/string.ts
-function minLengthValidator(report, schema, json) {
-	if (shouldSkipValidate(this.validateOptions, ["MIN_LENGTH"])) return;
+function minLengthValidator(ctx, report, schema, json) {
+	if (shouldSkipValidate(ctx.validateOptions, ["MIN_LENGTH"])) return;
 	if (typeof json !== "string") return;
 	if (unicodeLength(json) < schema.minLength) report.addError("MIN_LENGTH", [json.length, schema.minLength], void 0, schema, "minLength");
 }
-function maxLengthValidator(report, schema, json) {
-	if (shouldSkipValidate(this.validateOptions, ["MAX_LENGTH"])) return;
+function maxLengthValidator(ctx, report, schema, json) {
+	if (shouldSkipValidate(ctx.validateOptions, ["MAX_LENGTH"])) return;
 	if (typeof json !== "string") return;
 	if (unicodeLength(json) > schema.maxLength) report.addError("MAX_LENGTH", [json.length, schema.maxLength], void 0, schema, "maxLength");
 }
-function patternValidator(report, schema, json) {
-	if (shouldSkipValidate(this.validateOptions, ["PATTERN"])) return;
+function patternValidator(ctx, report, schema, json) {
+	if (shouldSkipValidate(ctx.validateOptions, ["PATTERN"])) return;
 	if (typeof json !== "string") return;
 	const result = compileSchemaRegex(schema.pattern);
 	if (!result.ok) {
@@ -29,46 +29,46 @@ function patternValidator(report, schema, json) {
 	}
 	if (!result.value.test(json)) report.addError("PATTERN", [schema.pattern, json], void 0, schema, "pattern");
 }
-function formatValidator(report, schema, json) {
-	if (this.options.formatAssertions === false) return;
-	if (this.options.formatAssertions === true) {
-		if (!isFormatAssertionVocabEnabled(schema, report, this.options.version)) return;
-	}
-	const isModernDraft = this.options.version === "draft2019-09" || this.options.version === "draft2020-12";
-	const formatValidatorFn = getFormatValidators(this.options)[schema.format];
+function formatValidator(ctx, report, schema, json) {
+	if (ctx.options.formatAssertions === false) return;
+	if (ctx.options.formatAssertions === true && !isFormatAssertionVocabEnabled(schema, report, ctx.options.version)) return;
+	const isModernDraft = ctx.options.version === "draft2019-09" || ctx.options.version === "draft2020-12";
+	const formatValidatorFn = resolveFormatValidator(schema.format, ctx.options);
 	if (typeof formatValidatorFn === "function") {
-		if (shouldSkipValidate(this.validateOptions, ["INVALID_FORMAT"])) return;
+		if (shouldSkipValidate(ctx.validateOptions, ["INVALID_FORMAT"])) return;
 		if (report.hasError("INVALID_TYPE", [schema.type, whatIs(json)])) return;
-		if (formatValidatorFn.length === 2) report.addAsyncTaskWithPath(formatValidatorFn, [json], function(result) {
+		if (formatValidatorFn.length === 2) report.addAsyncTaskWithPath(formatValidatorFn, [json], (result) => {
 			if (result !== true) report.addError("INVALID_FORMAT", [schema.format, JSON.stringify(json)], void 0, schema, "format");
 		});
 		else {
-			const result = formatValidatorFn.call(this, json);
+			const result = formatValidatorFn.call(ctx, json);
 			if (result instanceof Promise) {
 				const promiseResult = result;
 				report.addAsyncTaskWithPath(async (callback) => {
 					try {
 						callback(await promiseResult);
-					} catch (_error) {
+					} catch {
 						callback(false);
 					}
-				}, [], function(resolvedResult) {
+				}, [], (resolvedResult) => {
 					if (resolvedResult !== true) report.addError("INVALID_FORMAT", [schema.format, JSON.stringify(json)], void 0, schema, "format");
 				});
-			} else if (result !== true) report.addError("INVALID_FORMAT", [schema.format, JSON.stringify(json)], void 0, schema, "format");
+			} else if (!result) report.addError("INVALID_FORMAT", [schema.format, JSON.stringify(json)], void 0, schema, "format");
 		}
-	} else if (this.options.ignoreUnknownFormats !== true && !isModernDraft) report.addError("UNKNOWN_FORMAT", [schema.format], void 0, schema, "format");
+	} else if (ctx.options.ignoreUnknownFormats !== true && !isModernDraft) report.addError("UNKNOWN_FORMAT", [schema.format], void 0, schema, "format");
 }
-function contentEncodingValidator(report, schema, json) {
-	if (this.options.version !== "draft-07") return;
+function contentEncodingValidator(ctx, report, schema, json) {
+	if (ctx.options.version !== "draft-07") return;
 	if (typeof json !== "string") return;
-	if (schema.contentEncoding !== "base64") return;
+	const { contentEncoding } = schema;
+	if (contentEncoding !== "base64") return;
 	if (!isValidBase64(json)) report.addError("INVALID_FORMAT", ["contentEncoding:base64", JSON.stringify(json)], void 0, schema, "contentEncoding");
 }
-function contentMediaTypeValidator(report, schema, json) {
-	if (this.options.version !== "draft-07") return;
+function contentMediaTypeValidator(ctx, report, schema, json) {
+	if (ctx.options.version !== "draft-07") return;
 	if (typeof json !== "string") return;
-	if (schema.contentMediaType !== "application/json") return;
+	const { contentMediaType } = schema;
+	if (contentMediaType !== "application/json") return;
 	let payload = json;
 	if (schema.contentEncoding === "base64") {
 		const decoded = decodeBase64(json);

package/dist/validation/type.js

@@ -0,0 +1,34 @@
+import { whatIs } from "../utils/what-is.js";
+import { areEqual } from "../utils/json.js";
+import { shouldSkipValidate } from "./shared.js";
+//#region src/validation/type.ts
+function typeValidator(ctx, report, schema, json) {
+	if (shouldSkipValidate(ctx.validateOptions, ["INVALID_TYPE"])) return;
+	const jsonType = whatIs(json);
+	if (typeof schema.type === "string") {
+		if (jsonType !== schema.type && (jsonType !== "integer" || schema.type !== "number")) report.addError("INVALID_TYPE", [schema.type, jsonType], void 0, schema, "type");
+	} else if (!schema.type.includes(jsonType) && (jsonType !== "integer" || !schema.type.includes("number"))) report.addError("INVALID_TYPE", [JSON.stringify(schema.type), jsonType], void 0, schema, "type");
+}
+function enumValidator(ctx, report, schema, json) {
+	if (shouldSkipValidate(ctx.validateOptions, ["ENUM_CASE_MISMATCH", "ENUM_MISMATCH"])) return;
+	const eqOpts = { maxDepth: ctx.options.maxRecursionDepth };
+	const eqOptsCI = {
+		caseInsensitiveComparison: true,
+		maxDepth: ctx.options.maxRecursionDepth
+	};
+	let caseInsensitiveMatch = false, match = false;
+	for (const enumVal of schema.enum) if (areEqual(json, enumVal, eqOpts)) {
+		match = true;
+		break;
+	} else if (areEqual(json, enumVal, eqOptsCI)) caseInsensitiveMatch = true;
+	if (!match) {
+		const error = caseInsensitiveMatch && ctx.options.enumCaseInsensitiveComparison ? "ENUM_CASE_MISMATCH" : "ENUM_MISMATCH";
+		report.addError(error, [JSON.stringify(json)], void 0, schema, "enum");
+	}
+}
+function constValidator(ctx, report, schema, json) {
+	const constValue = schema.const;
+	if (!areEqual(json, constValue, { maxDepth: ctx.options.maxRecursionDepth })) report.addError("CONST", [JSON.stringify(constValue)], void 0, schema);
+}
+//#endregion
+export { constValidator, enumValidator, typeValidator };

package/dist/{z-schema-base.d.mts → z-schema-base.d.ts}

@@ -1,11 +1,11 @@
-import { FormatValidatorFn } from "./format-validators.mjs";
-import { ZSchemaOptions } from "./z-schema-options.mjs";
-import { Report } from "./report.mjs";
-import { Errors, ValidateError } from "./errors.mjs";
-import { SchemaCache } from "./schema-cache.mjs";
-import { SchemaValidator } from "./schema-validator.mjs";
-import { SchemaCompiler } from "./schema-compiler.mjs";
-import { JsonSchema, JsonSchemaInternal } from "./json-schema-versions.mjs";
+import { FormatValidatorFn } from "./format-validators.js";
+import { ZSchemaOptions } from "./z-schema-options.js";
+import { Report } from "./report.js";
+import { Errors, ValidateError } from "./errors.js";
+import { SchemaCache } from "./schema-cache.js";
+import { SchemaValidator } from "./schema-validator.js";
+import { SchemaCompiler } from "./schema-compiler.js";
+import { JsonSchema, JsonSchemaInternal } from "./json-schema-versions.js";
 
 //#region src/z-schema-base.d.ts
 interface ValidateOptions {
@@ -13,10 +13,10 @@ interface ValidateOptions {
   includeErrors?: Array<keyof typeof Errors>;
   excludeErrors?: Array<keyof typeof Errors>;
 }
-type ValidateResponse = {
+interface ValidateResponse {
   valid: boolean;
   err?: ValidateError;
-};
+}
 type ValidateCallback = (err: ValidateResponse['err'], valid: ValidateResponse['valid']) => void;
 declare class ZSchemaBase {
   scache: SchemaCache;
@@ -36,8 +36,7 @@ declare class ZSchemaBase {
   getDefaultSchemaId(): string;
   _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): true;
-  _validate(json: unknown, schema: JsonSchema | string): true;
+  _validate(json: unknown, schema: JsonSchema | string, options?: ValidateOptions): true;
   _validateSchema(schemaOrArr: JsonSchema | JsonSchema[]): true;
   /**
    * Register a format validator on this instance only (does not affect other instances or the global registry).

package/dist/{z-schema-base.mjs → z-schema-base.js}

@@ -1,18 +1,18 @@
-import { getRemotePath } from "./utils/uri.mjs";
-import { isObject, whatIs } from "./utils/what-is.mjs";
-import { isInternalKey } from "./json-schema.mjs";
-import { getValidateError } from "./errors.mjs";
-import { copyProp } from "./utils/properties.mjs";
-import { deepClone } from "./utils/clone.mjs";
-import { get, sortedKeys } from "./utils/json.mjs";
-import { Report } from "./report.mjs";
-import { VERSION_SCHEMA_URL_MAPPING } from "./json-schema-versions.mjs";
-import { defaultOptions, normalizeOptions } from "./z-schema-options.mjs";
-import { SchemaCache, prepareRemoteSchema } from "./schema-cache.mjs";
-import { getSupportedFormats } from "./format-validators.mjs";
-import { validate } from "./json-validation.mjs";
-import { SchemaCompiler } from "./schema-compiler.mjs";
-import { SchemaValidator } from "./schema-validator.mjs";
+import { getRemotePath } from "./utils/uri.js";
+import { isObject, whatIs } from "./utils/what-is.js";
+import { isInternalKey } from "./json-schema.js";
+import { getValidateError } from "./errors.js";
+import { copyProp } from "./utils/properties.js";
+import { deepClone } from "./utils/clone.js";
+import { get, sortedKeys } from "./utils/json.js";
+import { Report } from "./report.js";
+import { VERSION_SCHEMA_URL_MAPPING } from "./json-schema-versions.js";
+import { defaultOptions, normalizeOptions } from "./z-schema-options.js";
+import { SchemaCache, prepareRemoteSchema } from "./schema-cache.js";
+import { getSupportedFormats } from "./format-validators.js";
+import { validate } from "./json-validation.js";
+import { SchemaCompiler } from "./schema-compiler.js";
+import { SchemaValidator } from "./schema-validator.js";
 //#region src/z-schema-base.ts
 /**
 * Module-private symbol used by `ZSchema.create()` to authorise construction.
@@ -40,7 +40,7 @@ var ZSchemaBase = class {
 	* create a circular dependency).
 	*/
 	_jsonValidate(report, schema, json) {
-		return validate.call(this, report, schema, json);
+		return validate(this, report, schema, json);
 	}
 	getDefaultSchemaId() {
 		return this.options.version && this.options.version !== "none" ? VERSION_SCHEMA_URL_MAPPING[this.options.version] : VERSION_SCHEMA_URL_MAPPING[defaultOptions.version];
@@ -53,9 +53,9 @@ var ZSchemaBase = class {
 		if (!options) options = {};
 		this.validateOptions = options;
 		if (typeof schema !== "string" && typeof schema !== "boolean" && !isObject(schema)) {
-			const e = /* @__PURE__ */ new Error("Invalid .validate call - schema must be a string or object but " + whatIs(schema) + " was passed!");
+			const e = /* @__PURE__ */ new Error(`Invalid .validate call - schema must be a string or object but ${whatIs(schema)} was passed!`);
 			if (callback) {
-				setTimeout(function() {
+				setTimeout(() => {
 					callback(e, false);
 				}, 0);
 				return;
@@ -70,9 +70,9 @@ var ZSchemaBase = class {
 			const schemaName = schema;
 			_schema = this.scache.getSchema(report, schemaName);
 			if (!_schema) {
-				const e = /* @__PURE__ */ new Error("Schema with id '" + schemaName + "' wasn't found in the validator cache!");
+				const e = /* @__PURE__ */ new Error(`Schema with id '${schemaName}' wasn't found in the validator cache!`);
 				if (callback) {
-					setTimeout(function() {
+					setTimeout(() => {
 						callback(e, false);
 					}, 0);
 					return;
@@ -90,9 +90,9 @@ var ZSchemaBase = class {
 			report.rootSchema = _schema;
 			_schema = get(_schema, options.schemaPath);
 			if (!_schema) {
-				const e = /* @__PURE__ */ new Error("Schema path '" + options.schemaPath + "' wasn't found in the schema!");
+				const e = /* @__PURE__ */ new Error(`Schema path '${options.schemaPath}' wasn't found in the schema!`);
 				if (callback) {
-					setTimeout(function() {
+					setTimeout(() => {
 						callback(e, false);
 					}, 0);
 					return;
@@ -100,7 +100,7 @@ var ZSchemaBase = class {
 				throw e;
 			}
 		}
-		if (!foundError) validate.call(this, report, _schema, json);
+		if (!foundError) validate(this, report, _schema, json);
 		if (callback) {
 			report.processAsyncTasks(this.options.asyncTimeout, callback);
 			return;
@@ -171,8 +171,8 @@ var ZSchemaBase = class {
 		if (!err) return [];
 		const details = err.details || [];
 		const missingRefs = [];
-		function collect(details) {
-			for (const detail of details) {
+		function collect(items) {
+			for (const detail of items) {
 				if (detail.code === "UNRESOLVABLE_REFERENCE" || detail.code === "SCHEMA_NOT_REACHABLE") missingRefs.push(detail.params[0]);
 				if (detail.inner) collect(detail.inner);
 			}
@@ -188,9 +188,13 @@ var ZSchemaBase = class {
 	getMissingRemoteReferences(err) {
 		const missingReferences = this.getMissingReferences(err);
 		const missingRemoteReferences = [];
+		const seen = /* @__PURE__ */ new Set();
 		for (const ref of missingReferences) {
 			const remoteReference = getRemotePath(ref);
-			if (remoteReference && !missingRemoteReferences.includes(remoteReference)) missingRemoteReferences.push(remoteReference);
+			if (remoteReference && !seen.has(remoteReference)) {
+				seen.add(remoteReference);
+				missingRemoteReferences.push(remoteReference);
+			}
 		}
 		return missingRemoteReferences;
 	}
@@ -203,24 +207,25 @@ var ZSchemaBase = class {
 	getResolvedSchema(schemaId) {
 		const report = new Report(this.options);
 		const schema = this.scache.getSchemaByUri(report, schemaId);
-		if (!schema) return void 0;
+		if (!schema) return;
 		const clonedSchema = deepClone(schema, this.options.maxRecursionDepth);
 		const visited = /* @__PURE__ */ new WeakSet();
-		const cleanup = function(schema) {
-			let key;
-			const typeOf = whatIs(schema);
+		const cleanup = (node) => {
+			const typeOf = whatIs(node);
 			if (typeOf !== "object" && typeOf !== "array") return;
-			if (visited.has(schema)) return;
-			visited.add(schema);
-			if (schema.$ref && schema.__$refResolved) {
-				const from = schema.__$refResolved;
-				const to = schema;
-				delete schema.$ref;
-				delete schema.__$refResolved;
-				for (key in from) copyProp(from, to, key);
+			if (visited.has(node)) return;
+			visited.add(node);
+			const schemaNode = node;
+			if (schemaNode.$ref && schemaNode.__$refResolved) {
+				const from = schemaNode.__$refResolved;
+				const to = schemaNode;
+				delete schemaNode.$ref;
+				delete schemaNode.__$refResolved;
+				for (const key in from) if (Object.hasOwn(from, key)) copyProp(from, to, key);
 			}
-			for (key in schema) if (Object.hasOwn(schema, key)) if (isInternalKey(key)) delete schema[key];
-			else cleanup(schema[key]);
+			const record = node;
+			for (const key in record) if (Object.hasOwn(record, key)) if (isInternalKey(key)) delete record[key];
+			else cleanup(record[key]);
 		};
 		cleanup(clonedSchema);
 		return clonedSchema;

package/dist/{z-schema-options.d.mts → z-schema-options.d.ts}

@@ -1,6 +1,6 @@
-import { FormatValidatorFn } from "./format-validators.mjs";
-import { Report } from "./report.mjs";
-import { JsonSchemaVersion } from "./json-schema-versions.mjs";
+import { FormatValidatorFn } from "./format-validators.js";
+import { Report } from "./report.js";
+import { JsonSchemaVersion } from "./json-schema-versions.js";
 
 //#region src/z-schema-options.d.ts
 interface ZSchemaOptions {

package/dist/{z-schema-options.mjs → z-schema-options.js}

@@ -1,6 +1,6 @@
-import { MAX_ASYNC_TIMEOUT } from "./utils/constants.mjs";
-import { shallowClone } from "./utils/clone.mjs";
-import { CURRENT_DEFAULT_SCHEMA_VERSION } from "./json-schema-versions.mjs";
+import { MAX_ASYNC_TIMEOUT } from "./utils/constants.js";
+import { shallowClone } from "./utils/clone.js";
+import { CURRENT_DEFAULT_SCHEMA_VERSION } from "./json-schema-versions.js";
 //#region src/z-schema-options.ts
 const defaultOptions = {
 	version: CURRENT_DEFAULT_SCHEMA_VERSION,
@@ -33,7 +33,7 @@ const normalizeOptions = (options) => {
 	let normalized;
 	if (typeof options === "object") {
 		let keys = Object.keys(options);
-		for (const key of keys) if (defaultOptions[key] === void 0) throw new Error("Unexpected option passed to constructor: " + key);
+		for (const key of keys) if (defaultOptions[key] === void 0) throw new Error(`Unexpected option passed to constructor: ${key}`);
 		keys = Object.keys(defaultOptions);
 		for (const key of keys) if (options[key] === void 0) options[key] = shallowClone(defaultOptions[key]);
 		normalized = options;

package/dist/{z-schema-reader.d.mts → z-schema-reader.d.ts}

@@ -1,4 +1,4 @@
-import { JsonSchema } from "./json-schema-versions.mjs";
+import { JsonSchema } from "./json-schema-versions.js";
 
 //#region src/z-schema-reader.d.ts
 type SchemaReader = (uri: string) => JsonSchema;

package/dist/{z-schema-versions.mjs → z-schema-versions.js}

@@ -1,24 +1,24 @@
-import { normalizeOptions } from "./z-schema-options.mjs";
-import { SchemaCache } from "./schema-cache.mjs";
-import draft_04_schema_default from "./schemas/draft-04-schema.mjs";
-import draft_06_schema_default from "./schemas/draft-06-schema.mjs";
-import draft_07_schema_default from "./schemas/draft-07-schema.mjs";
-import draft_2019_09_meta_applicator_default from "./schemas/draft-2019-09-meta-applicator.mjs";
-import draft_2019_09_meta_content_default from "./schemas/draft-2019-09-meta-content.mjs";
-import draft_2019_09_meta_core_default from "./schemas/draft-2019-09-meta-core.mjs";
-import draft_2019_09_meta_format_default from "./schemas/draft-2019-09-meta-format.mjs";
-import draft_2019_09_meta_meta_data_default from "./schemas/draft-2019-09-meta-meta-data.mjs";
-import draft_2019_09_meta_validation_default from "./schemas/draft-2019-09-meta-validation.mjs";
-import draft_2019_09_schema_default from "./schemas/draft-2019-09-schema.mjs";
-import draft_2020_12_meta_applicator_default from "./schemas/draft-2020-12-meta-applicator.mjs";
-import draft_2020_12_meta_content_default from "./schemas/draft-2020-12-meta-content.mjs";
-import draft_2020_12_meta_core_default from "./schemas/draft-2020-12-meta-core.mjs";
-import draft_2020_12_meta_format_annotation_default from "./schemas/draft-2020-12-meta-format-annotation.mjs";
-import draft_2020_12_meta_format_assertion_default from "./schemas/draft-2020-12-meta-format-assertion.mjs";
-import draft_2020_12_meta_meta_data_default from "./schemas/draft-2020-12-meta-meta-data.mjs";
-import draft_2020_12_meta_unevaluated_default from "./schemas/draft-2020-12-meta-unevaluated.mjs";
-import draft_2020_12_meta_validation_default from "./schemas/draft-2020-12-meta-validation.mjs";
-import draft_2020_12_schema_default from "./schemas/draft-2020-12-schema.mjs";
+import { normalizeOptions } from "./z-schema-options.js";
+import { SchemaCache } from "./schema-cache.js";
+import draft_04_schema_default from "./schemas/draft-04-schema.js";
+import draft_06_schema_default from "./schemas/draft-06-schema.js";
+import draft_07_schema_default from "./schemas/draft-07-schema.js";
+import draft_2019_09_meta_applicator_default from "./schemas/draft-2019-09-meta-applicator.js";
+import draft_2019_09_meta_content_default from "./schemas/draft-2019-09-meta-content.js";
+import draft_2019_09_meta_core_default from "./schemas/draft-2019-09-meta-core.js";
+import draft_2019_09_meta_format_default from "./schemas/draft-2019-09-meta-format.js";
+import draft_2019_09_meta_meta_data_default from "./schemas/draft-2019-09-meta-meta-data.js";
+import draft_2019_09_meta_validation_default from "./schemas/draft-2019-09-meta-validation.js";
+import draft_2019_09_schema_default from "./schemas/draft-2019-09-schema.js";
+import draft_2020_12_meta_applicator_default from "./schemas/draft-2020-12-meta-applicator.js";
+import draft_2020_12_meta_content_default from "./schemas/draft-2020-12-meta-content.js";
+import draft_2020_12_meta_core_default from "./schemas/draft-2020-12-meta-core.js";
+import draft_2020_12_meta_format_annotation_default from "./schemas/draft-2020-12-meta-format-annotation.js";
+import draft_2020_12_meta_format_assertion_default from "./schemas/draft-2020-12-meta-format-assertion.js";
+import draft_2020_12_meta_meta_data_default from "./schemas/draft-2020-12-meta-meta-data.js";
+import draft_2020_12_meta_unevaluated_default from "./schemas/draft-2020-12-meta-unevaluated.js";
+import draft_2020_12_meta_validation_default from "./schemas/draft-2020-12-meta-validation.js";
+import draft_2020_12_schema_default from "./schemas/draft-2020-12-schema.js";
 //#region src/z-schema-versions.ts
 const Draft4Schema = draft_04_schema_default;
 const Draft6Schema = draft_06_schema_default;

package/dist/{z-schema.d.mts → z-schema.d.ts}

@@ -1,13 +1,11 @@
-import { FormatValidatorFn } from "./format-validators.mjs";
-import { ZSchemaOptions } from "./z-schema-options.mjs";
-import { ValidateOptions, ValidateResponse, ZSchemaBase } from "./z-schema-base.mjs";
-import { JsonSchema } from "./json-schema-versions.mjs";
-import { SchemaReader } from "./z-schema-reader.mjs";
+import { FormatValidatorFn } from "./format-validators.js";
+import { ZSchemaOptions } from "./z-schema-options.js";
+import { ValidateOptions, ValidateResponse, ZSchemaBase } from "./z-schema-base.js";
+import { JsonSchema } from "./json-schema-versions.js";
+import { SchemaReader } from "./z-schema-reader.js";
 
 //#region src/z-schema.d.ts
 declare class ZSchema extends ZSchemaBase {
-  /** @internal Use ZSchema.create() instead. */
-  constructor(options: ZSchemaOptions | undefined, token: symbol);
   /**
    * Register a global format validator available to all instances.
    * @param name - The format name (e.g. `'email'`, `'date'`).
@@ -125,8 +123,6 @@ declare class ZSchema extends ZSchemaBase {
  * Created via `ZSchema.create({ safe: true })`.
  */
 declare class ZSchemaSafe extends ZSchemaBase {
-  /** @internal Use ZSchema.create() instead. */
-  constructor(options: ZSchemaOptions | undefined, token: symbol);
   /**
    * Validate JSON data against a schema.
    * @param json - The data to validate.
@@ -147,8 +143,6 @@ declare class ZSchemaSafe extends ZSchemaBase {
  * Created via `ZSchema.create({ async: true })`.
  */
 declare class ZSchemaAsync extends ZSchemaBase {
-  /** @internal Use ZSchema.create() instead. */
-  constructor(options: ZSchemaOptions | undefined, token: symbol);
   /**
    * Validate JSON data against a schema asynchronously.
    * @param json - The data to validate.
@@ -171,8 +165,6 @@ declare class ZSchemaAsync extends ZSchemaBase {
  * Created via `ZSchema.create({ async: true, safe: true })`.
  */
 declare class ZSchemaAsyncSafe extends ZSchemaBase {
-  /** @internal Use ZSchema.create() instead. */
-  constructor(options: ZSchemaOptions | undefined, token: symbol);
   /**
    * Validate JSON data against a schema asynchronously.
    * The promise always resolves (never rejects).