z-schema 12.0.4 → 12.1.0

package/dist/errors.d.mts

@@ -0,0 +1,64 @@
+import { SchemaErrorDetail } from "./report.mjs";
+
+//#region src/errors.d.ts
+type ErrorCode = keyof typeof Errors;
+type ErrorParam = string | number | Array<string | number>;
+declare const Errors: {
+  INVALID_TYPE: string;
+  INVALID_FORMAT: string;
+  ENUM_MISMATCH: string;
+  ENUM_CASE_MISMATCH: string;
+  ANY_OF_MISSING: string;
+  ONE_OF_MISSING: string;
+  ONE_OF_MULTIPLE: string;
+  NOT_PASSED: string;
+  ARRAY_LENGTH_SHORT: string;
+  ARRAY_LENGTH_LONG: string;
+  ARRAY_UNIQUE: string;
+  ARRAY_ADDITIONAL_ITEMS: string;
+  ARRAY_UNEVALUATED_ITEMS: string;
+  MULTIPLE_OF: string;
+  MINIMUM: string;
+  MINIMUM_EXCLUSIVE: string;
+  MAXIMUM: string;
+  MAXIMUM_EXCLUSIVE: string;
+  OBJECT_PROPERTIES_MINIMUM: string;
+  OBJECT_PROPERTIES_MAXIMUM: string;
+  OBJECT_MISSING_REQUIRED_PROPERTY: string;
+  OBJECT_ADDITIONAL_PROPERTIES: string;
+  OBJECT_UNEVALUATED_PROPERTIES: string;
+  OBJECT_DEPENDENCY_KEY: string;
+  MIN_LENGTH: string;
+  MAX_LENGTH: string;
+  PATTERN: string;
+  KEYWORD_TYPE_EXPECTED: string;
+  KEYWORD_UNDEFINED_STRICT: string;
+  KEYWORD_UNEXPECTED: string;
+  KEYWORD_MUST_BE: string;
+  KEYWORD_DEPENDENCY: string;
+  KEYWORD_PATTERN: string;
+  KEYWORD_VALUE_TYPE: string;
+  UNKNOWN_FORMAT: string;
+  CUSTOM_MODE_FORCE_PROPERTIES: string;
+  REF_UNRESOLVED: string;
+  UNRESOLVABLE_REFERENCE: string;
+  SCHEMA_NOT_REACHABLE: string;
+  SCHEMA_TYPE_EXPECTED: string;
+  SCHEMA_NOT_AN_OBJECT: string;
+  ASYNC_TIMEOUT: string;
+  PARENT_SCHEMA_VALIDATION_FAILED: string;
+  REMOTE_NOT_VALID: string;
+  SCHEMA_IS_FALSE: string;
+  CONST: string;
+  CONTAINS: string;
+  PROPERTY_NAMES: string;
+  COLLECT_EVALUATED_DEPTH_EXCEEDED: string;
+  MAX_RECURSION_DEPTH_EXCEEDED: string;
+};
+declare class ValidateError extends Error {
+  name: string;
+  details?: SchemaErrorDetail[];
+  constructor(message: string, details?: SchemaErrorDetail[]);
+}
+//#endregion
+export { ErrorCode, ErrorParam, Errors, ValidateError };

package/dist/errors.mjs

@@ -0,0 +1,67 @@
+//#region src/errors.ts
+const Errors = {
+	INVALID_TYPE: "Expected type {0} but found type {1}",
+	INVALID_FORMAT: "Object didn't pass validation for format {0}: {1}",
+	ENUM_MISMATCH: "No enum match for: {0}",
+	ENUM_CASE_MISMATCH: "Enum does not match case for: {0}",
+	ANY_OF_MISSING: "Data does not match any schemas from 'anyOf'",
+	ONE_OF_MISSING: "Data does not match any schemas from 'oneOf'",
+	ONE_OF_MULTIPLE: "Data is valid against more than one schema from 'oneOf'",
+	NOT_PASSED: "Data matches schema from 'not'",
+	ARRAY_LENGTH_SHORT: "Array is too short ({0}), minimum {1}",
+	ARRAY_LENGTH_LONG: "Array is too long ({0}), maximum {1}",
+	ARRAY_UNIQUE: "Array items are not unique (indexes {0} and {1})",
+	ARRAY_ADDITIONAL_ITEMS: "Additional items not allowed",
+	ARRAY_UNEVALUATED_ITEMS: "Unevaluated items are not allowed",
+	MULTIPLE_OF: "Value {0} is not a multiple of {1}",
+	MINIMUM: "Value {0} is less than minimum {1}",
+	MINIMUM_EXCLUSIVE: "Value {0} is equal or less than exclusive minimum {1}",
+	MAXIMUM: "Value {0} is greater than maximum {1}",
+	MAXIMUM_EXCLUSIVE: "Value {0} is equal or greater than exclusive maximum {1}",
+	OBJECT_PROPERTIES_MINIMUM: "Too few properties defined ({0}), minimum {1}",
+	OBJECT_PROPERTIES_MAXIMUM: "Too many properties defined ({0}), maximum {1}",
+	OBJECT_MISSING_REQUIRED_PROPERTY: "Missing required property: {0}",
+	OBJECT_ADDITIONAL_PROPERTIES: "Additional properties not allowed: {0}",
+	OBJECT_UNEVALUATED_PROPERTIES: "Unevaluated properties are not allowed: {0}",
+	OBJECT_DEPENDENCY_KEY: "Dependency failed - key must exist: {0} (due to key: {1})",
+	MIN_LENGTH: "String is too short ({0} chars), minimum {1}",
+	MAX_LENGTH: "String is too long ({0} chars), maximum {1}",
+	PATTERN: "String does not match pattern {0}: {1}",
+	KEYWORD_TYPE_EXPECTED: "Keyword '{0}' is expected to be of type '{1}'",
+	KEYWORD_UNDEFINED_STRICT: "Keyword '{0}' must be defined in strict mode",
+	KEYWORD_UNEXPECTED: "Keyword '{0}' is not expected to appear in the schema",
+	KEYWORD_MUST_BE: "Keyword '{0}' must be {1}",
+	KEYWORD_DEPENDENCY: "Keyword '{0}' requires keyword '{1}'",
+	KEYWORD_PATTERN: "Keyword '{0}' is not a valid RegExp pattern: {1}",
+	KEYWORD_VALUE_TYPE: "Each element of keyword '{0}' array must be a '{1}'",
+	UNKNOWN_FORMAT: "There is no validation function for format '{0}'",
+	CUSTOM_MODE_FORCE_PROPERTIES: "{0} must define at least one property if present",
+	REF_UNRESOLVED: "Reference has not been resolved during compilation: {0}",
+	UNRESOLVABLE_REFERENCE: "Reference could not be resolved: {0}",
+	SCHEMA_NOT_REACHABLE: "Validator was not able to read schema with uri: {0}",
+	SCHEMA_TYPE_EXPECTED: "Schema is expected to be of type 'object'",
+	SCHEMA_NOT_AN_OBJECT: "Schema is not an object: {0}",
+	ASYNC_TIMEOUT: "{0} asynchronous task(s) have timed out after {1} ms",
+	PARENT_SCHEMA_VALIDATION_FAILED: "Schema failed to validate against its parent schema, see inner errors for details.",
+	REMOTE_NOT_VALID: "Remote reference didn't compile successfully: {0}",
+	SCHEMA_IS_FALSE: "Boolean schema \"false\" is always invalid.",
+	CONST: "Value does not match const: {0}",
+	CONTAINS: "Array does not contain an item matching the schema",
+	PROPERTY_NAMES: "Property name {0} does not match the propertyNames schema",
+	COLLECT_EVALUATED_DEPTH_EXCEEDED: "Schema nesting depth exceeded maximum ({0}) during unevaluated items/properties collection",
+	MAX_RECURSION_DEPTH_EXCEEDED: "Maximum recursion depth ({0}) exceeded. If your schema or data is deeply nested and valid, increase the maxRecursionDepth option."
+};
+var ValidateError = class extends Error {
+	name;
+	details;
+	constructor(message, details) {
+		super(message);
+		this.name = "z-schema validation error";
+		this.details = details;
+	}
+};
+function getValidateError({ message, details }) {
+	return new ValidateError(message || "", details);
+}
+//#endregion
+export { Errors, ValidateError, getValidateError };

package/dist/format-validators.d.mts

@@ -0,0 +1,14 @@
+//#region src/format-validators.d.ts
+type FormatValidatorFn = (input: unknown) => boolean | Promise<boolean>;
+interface FormatValidatorsOptions {
+  strictUris?: boolean;
+  customFormats?: Record<string, FormatValidatorFn | null>;
+}
+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(customFormats?: Record<string, FormatValidatorFn | null>): string[];
+declare function isFormatSupported(name: string, customFormats?: Record<string, FormatValidatorFn | null>): boolean;
+declare function getRegisteredFormats(): string[];
+//#endregion
+export { FormatValidatorFn, FormatValidatorsOptions, getFormatValidators, getRegisteredFormats, getSupportedFormats, isFormatSupported, registerFormat, unregisterFormat };

package/dist/format-validators.mjs

@@ -0,0 +1,261 @@
+import { sortedKeys } from "./utils/json.mjs";
+import { isValidRfc3339Date } from "./utils/date.mjs";
+import { isValidHostname, isValidIdnHostname } from "./utils/hostname.mjs";
+import { parseRfc3339Time } from "./utils/time.mjs";
+import isEmailModule from "validator/lib/isEmail.js";
+import isIPModule from "validator/lib/isIP.js";
+import isURLModule from "validator/lib/isURL.js";
+//#region src/format-validators.ts
+const dateValidator = (date) => {
+	if (typeof date !== "string") return true;
+	const matches = /^([0-9]{4})-([0-9]{2})-([0-9]{2})$/.exec(date);
+	if (matches === null) return false;
+	return isValidRfc3339Date(parseInt(matches[1], 10), parseInt(matches[2], 10), parseInt(matches[3], 10));
+};
+const dateTimeValidator = (dateTime) => {
+	if (typeof dateTime !== "string") return true;
+	const s = dateTime.toLowerCase().split("t");
+	if (s.length !== 2) return false;
+	const datePart = s[0];
+	const timePart = s[1];
+	const dateMatches = /^([0-9]{4})-([0-9]{2})-([0-9]{2})$/.exec(datePart);
+	if (dateMatches === null) return false;
+	if (!isValidRfc3339Date(parseInt(dateMatches[1], 10), parseInt(dateMatches[2], 10), parseInt(dateMatches[3], 10))) return false;
+	return parseRfc3339Time(timePart) !== null;
+};
+const emailValidator = (email) => {
+	if (typeof email !== "string") return true;
+	if (isEmailModule.default(email, {
+		require_tld: true,
+		allow_ip_domain: true
+	})) return true;
+	const ipv6Literal = /^(.+)@\[IPv6:([^\]]+)\]$/i.exec(email);
+	if (!ipv6Literal) return false;
+	const localPart = ipv6Literal[1];
+	const addressPart = ipv6Literal[2];
+	if (!isIPModule.default(addressPart, 6)) return false;
+	return isEmailModule.default(`${localPart}@example.com`, { require_tld: true });
+};
+const hostnameValidator = (hostname) => {
+	if (typeof hostname !== "string") return true;
+	return isValidHostname(hostname);
+};
+const ipv4Validator = (ipv4) => {
+	if (typeof ipv4 !== "string") return true;
+	return isIPModule.default(ipv4, 4);
+};
+const ipv6Validator = (ipv6) => {
+	if (typeof ipv6 !== "string") return true;
+	if (ipv6.includes("%")) return false;
+	return isIPModule.default(ipv6, 6);
+};
+const regexValidator = (input) => {
+	if (typeof input !== "string") return true;
+	const invalidEscapes = new Set(["a"]);
+	for (let idx = 0; idx < input.length; idx++) {
+		if (input[idx] !== "\\") continue;
+		idx++;
+		if (idx >= input.length) return false;
+		const escaped = input[idx];
+		if (invalidEscapes.has(escaped)) return false;
+	}
+	try {
+		RegExp(input);
+		return true;
+	} catch (_e) {
+		return false;
+	}
+};
+const durationValidator = (input) => {
+	if (typeof input !== "string") return true;
+	if (!/^P[\x00-\x7F]*$/.test(input)) return false;
+	if (!input.startsWith("P")) return false;
+	const body = input.slice(1);
+	if (body.length === 0) return false;
+	if (body.includes("W")) return /^\d+W$/.test(body);
+	const parts = body.split("T");
+	if (parts.length > 2) return false;
+	const datePart = parts[0];
+	const timePart = parts.length === 2 ? parts[1] : void 0;
+	if (datePart.length > 0 && !/^(?:\d+Y(?:\d+M(?:\d+D)?)?|\d+M(?:\d+D)?|\d+D)$/.test(datePart)) return false;
+	const hasDateComponent = /\d+[YMD]/.test(datePart);
+	let hasTimeComponent = false;
+	if (timePart !== void 0) {
+		if (timePart.length === 0) return false;
+		if (!/^(?:\d+H(?:\d+M(?:\d+S)?)?|\d+M(?:\d+S)?|\d+S)$/.test(timePart)) return false;
+		hasTimeComponent = /\d+[HMS]/.test(timePart);
+		if (!hasTimeComponent) return false;
+	}
+	return hasDateComponent || hasTimeComponent;
+};
+const uuidValidator = (input) => {
+	if (typeof input !== "string") return true;
+	return /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(input);
+};
+const strictUriValidator = (uri) => typeof uri !== "string" || isURLModule.default(uri);
+const hasValidPercentEncoding = (str) => {
+	for (let i = 0; i < str.length; i++) if (str[i] === "%") {
+		if (i + 2 >= str.length || !/[0-9a-fA-F]/.test(str[i + 1]) || !/[0-9a-fA-F]/.test(str[i + 2])) return false;
+	}
+	return true;
+};
+const uriValidator = function(uri) {
+	if (typeof uri !== "string") return true;
+	if (/[^\x00-\x7F]/.test(uri)) return false;
+	if (!hasValidPercentEncoding(uri)) return false;
+	const match = uri.match(/^([a-zA-Z][a-zA-Z0-9+.-]*):\/\/([^/?#]*)/);
+	if (match) {
+		const authority = match[2];
+		const atIndex = authority.indexOf("@");
+		if (atIndex > 0) {
+			const userinfo = authority.substring(0, atIndex);
+			if (userinfo.includes("[") || userinfo.includes("]")) return false;
+		}
+		let hostPort = atIndex >= 0 ? authority.substring(atIndex + 1) : authority;
+		if (hostPort.startsWith("[")) {
+			const bracketEnd = hostPort.indexOf("]");
+			if (bracketEnd >= 0) hostPort = hostPort.substring(bracketEnd + 1);
+		}
+		const colonIndex = hostPort.lastIndexOf(":");
+		if (colonIndex >= 0) {
+			const port = hostPort.substring(colonIndex + 1);
+			if (port.length > 0 && !/^\d+$/.test(port)) return false;
+		}
+	}
+	return /^[a-zA-Z][a-zA-Z0-9+.-]*:[^"\\<>^{}^`| ]*$/.test(uri);
+};
+const uriReferenceValidator = (uri) => {
+	if (typeof uri !== "string") return true;
+	if (/[^\x00-\x7F]/.test(uri)) return false;
+	return /^([a-zA-Z][a-zA-Z0-9+.-]*:)?[^"\\<>^{}^`| ]*$/.test(uri);
+};
+const uriTemplateValidator = (uri) => {
+	if (typeof uri !== "string") return true;
+	if (!/^([a-zA-Z][a-zA-Z0-9+.-]*:)?[^"\\<>^`| ]*$/.test(uri)) return false;
+	let inExpression = false;
+	for (let idx = 0; idx < uri.length; idx++) {
+		const ch = uri[idx];
+		if (ch === "{") {
+			if (inExpression) return false;
+			inExpression = true;
+		} else if (ch === "}") {
+			if (!inExpression) return false;
+			inExpression = false;
+		}
+	}
+	return !inExpression;
+};
+const hasValidTildeEscapes = (segment) => {
+	for (let i = 0; i < segment.length; i++) if (segment[i] === "~") {
+		const next = segment[i + 1];
+		if (next !== "0" && next !== "1") return false;
+		i++;
+	}
+	return true;
+};
+const jsonPointerValidator = (pointer) => {
+	if (typeof pointer !== "string") return true;
+	if (pointer === "") return true;
+	if (!/^(?:\/[^/]*)+$/.test(pointer)) return false;
+	const tokens = pointer.split("/").slice(1);
+	for (const token of tokens) if (!hasValidTildeEscapes(token)) return false;
+	return true;
+};
+const relativeJsonPointerValidator = (pointer) => {
+	if (typeof pointer !== "string") return true;
+	const match = pointer.match(/^(0|[1-9]\d*)(.*)$/);
+	if (!match) return false;
+	const suffix = match[2];
+	if (suffix === "" || suffix === "#") return true;
+	if (!suffix.startsWith("/")) return false;
+	if (!/^(?:\/[^/]*)+$/.test(suffix)) return false;
+	const tokens = suffix.split("/").slice(1);
+	for (const token of tokens) if (!hasValidTildeEscapes(token)) return false;
+	return true;
+};
+const timeValidator = (time) => {
+	if (typeof time !== "string") return true;
+	return parseRfc3339Time(time) !== null;
+};
+const idnEmailValidator = (email) => {
+	if (typeof email !== "string") return true;
+	return /^[^\s@]+@[^\s@]+$/.test(email);
+};
+const idnHostnameValidator = (hostname) => {
+	if (typeof hostname !== "string") return true;
+	return isValidIdnHostname(hostname);
+};
+const iriValidator = (iri) => {
+	if (typeof iri !== "string") return true;
+	if (!/^[a-zA-Z][a-zA-Z0-9+.-]*:[^"\\<>^{}^`| ]*$/u.test(iri)) return false;
+	try {
+		new URL(iri);
+		return true;
+	} catch (_e) {
+		return false;
+	}
+};
+const iriReferenceValidator = (iriReference) => {
+	if (typeof iriReference !== "string") return true;
+	return /^([a-zA-Z][a-zA-Z0-9+.-]*:)?[^"\\<>^{}^`| ]*$/u.test(iriReference);
+};
+const inbuiltValidators = {
+	date: dateValidator,
+	"date-time": dateTimeValidator,
+	email: emailValidator,
+	hostname: hostnameValidator,
+	"host-name": hostnameValidator,
+	ipv4: ipv4Validator,
+	ipv6: ipv6Validator,
+	regex: regexValidator,
+	uri: uriValidator,
+	"strict-uri": strictUriValidator,
+	"uri-reference": uriReferenceValidator,
+	"uri-template": uriTemplateValidator,
+	"json-pointer": jsonPointerValidator,
+	"relative-json-pointer": relativeJsonPointerValidator,
+	time: timeValidator,
+	"idn-email": idnEmailValidator,
+	"idn-hostname": idnHostnameValidator,
+	iri: iriValidator,
+	"iri-reference": iriReferenceValidator,
+	duration: durationValidator,
+	uuid: uuidValidator
+};
+const customValidators = {};
+function getFormatValidators(options) {
+	return {
+		...inbuiltValidators,
+		...options?.strictUris ? { uri: strictUriValidator } : {},
+		...customValidators,
+		...options?.customFormats || {}
+	};
+}
+function registerFormat(name, validatorFunction) {
+	customValidators[name] = validatorFunction;
+}
+function unregisterFormat(name) {
+	delete customValidators[name];
+}
+function getSupportedFormats(customFormats) {
+	const merged = {
+		...inbuiltValidators,
+		...customValidators,
+		...customFormats
+	};
+	return sortedKeys(merged).filter((key) => merged[key] != null);
+}
+function isFormatSupported(name, customFormats) {
+	if (customFormats) {
+		const custom = customFormats[name];
+		if (custom === null) return false;
+		if (custom != null) return true;
+	}
+	if (name in customValidators) return customValidators[name] != null;
+	return name in inbuiltValidators;
+}
+function getRegisteredFormats() {
+	return sortedKeys(customValidators);
+}
+//#endregion
+export { getFormatValidators, getRegisteredFormats, getSupportedFormats, isFormatSupported, registerFormat, unregisterFormat };

package/dist/index.d.mts

@@ -0,0 +1,10 @@
+import { FormatValidatorFn, FormatValidatorsOptions, getFormatValidators, getRegisteredFormats, getSupportedFormats, isFormatSupported, registerFormat, unregisterFormat } from "./format-validators.mjs";
+import { ZSchemaOptions } from "./z-schema-options.mjs";
+import { Report, SchemaErrorDetail } from "./report.mjs";
+import { ErrorCode, ErrorParam, Errors, ValidateError } from "./errors.mjs";
+import { ValidateOptions, ValidateResponse } from "./z-schema-base.mjs";
+import { JsonSchemaCommon, JsonSchemaType } from "./json-schema.mjs";
+import { JsonSchema, JsonSchemaDraft201909, JsonSchemaDraft202012, JsonSchemaDraft4, JsonSchemaDraft6, JsonSchemaDraft7, JsonSchemaVersion } from "./json-schema-versions.mjs";
+import { SchemaReader } from "./z-schema-reader.mjs";
+import { ZSchema, ZSchemaAsync, ZSchemaAsyncSafe, ZSchemaSafe } from "./z-schema.mjs";
+export { type ErrorCode, type ErrorParam, type Errors, type FormatValidatorFn, type FormatValidatorsOptions, type JsonSchema, type JsonSchemaCommon, type JsonSchemaDraft201909, type JsonSchemaDraft202012, type JsonSchemaDraft4, type JsonSchemaDraft6, type JsonSchemaDraft7, type JsonSchemaType, type JsonSchemaVersion, type Report, type SchemaErrorDetail, type SchemaReader, ValidateError, type ValidateOptions, type ValidateResponse, type ZSchema, type ZSchemaAsync, type ZSchemaAsyncSafe, type ZSchemaOptions, type ZSchemaSafe, ZSchema as default, getFormatValidators, getRegisteredFormats, getSupportedFormats, isFormatSupported, registerFormat, unregisterFormat };

package/dist/index.mjs

@@ -0,0 +1,7 @@
+import { ValidateError } from "./errors.mjs";
+import { getFormatValidators, getRegisteredFormats, getSupportedFormats, isFormatSupported, registerFormat, unregisterFormat } from "./format-validators.mjs";
+import { ZSchema } from "./z-schema.mjs";
+//#region src/index.ts
+var src_default = ZSchema;
+//#endregion
+export { ValidateError, src_default as default, getFormatValidators, getRegisteredFormats, getSupportedFormats, isFormatSupported, registerFormat, unregisterFormat };

package/dist/json-schema-versions.d.mts

@@ -0,0 +1,137 @@
+import { JsonSchemaCommon, ZSchemaInternalProperties } from "./json-schema.mjs";
+
+//#region src/json-schema-versions.d.ts
+type JsonSchemaVersion = 'draft-04' | 'draft-06' | 'draft-07' | 'draft2019-09' | 'draft2020-12';
+/** Union of all draft-specific schema interfaces — the public API type. */
+type JsonSchema = JsonSchemaDraft4 | JsonSchemaDraft6 | JsonSchemaDraft7 | JsonSchemaDraft201909 | JsonSchemaDraft202012;
+/**
+ * Superset of ALL draft-specific properties with the widest possible types.
+ * Use inside the validator where the active draft is not known at compile time.
+ *
+ * NOTE: this is a manually defined interface (not a computed intersection)
+ * because `exclusiveMinimum` is `boolean` in Draft-04 and `number` in
+ * Draft-06+, which would yield `never` in a plain intersection.
+ */
+interface JsonSchemaAll extends JsonSchemaCommon {
+  /** Pre-`$id` identifier (draft-04 only). */
+  id?: string;
+  /** Schema identifier (replaces `id` from draft-06 onward). */
+  $id?: string;
+  const?: unknown;
+  contains?: JsonSchema;
+  propertyNames?: JsonSchema;
+  examples?: unknown[];
+  if?: JsonSchema | boolean;
+  then?: JsonSchema | boolean;
+  else?: JsonSchema | boolean;
+  contentEncoding?: string;
+  contentMediaType?: string;
+  $defs?: Record<string, JsonSchema>;
+  $anchor?: string;
+  $vocabulary?: Record<string, boolean>;
+  $recursiveAnchor?: boolean;
+  $recursiveRef?: string;
+  dependentSchemas?: Record<string, JsonSchema>;
+  dependentRequired?: Record<string, string[]>;
+  unevaluatedItems?: JsonSchema | boolean;
+  unevaluatedProperties?: JsonSchema | boolean;
+  maxContains?: number;
+  minContains?: number;
+  $dynamicAnchor?: string;
+  $dynamicRef?: string;
+  prefixItems?: Array<JsonSchema | boolean>;
+}
+/**
+ * Internal schema type used throughout the validator. Based on `JsonSchemaAll`
+ * so that validators can access any draft-specific property without narrowing.
+ */
+type JsonSchemaInternal = JsonSchemaAll & ZSchemaInternalProperties;
+/**
+ * JSON Schema Draft-04.
+ *
+ * Key differences from later drafts:
+ * - Uses `id` instead of `$id`.
+ * - `exclusiveMinimum`/`exclusiveMaximum` are boolean modifiers on `minimum`/`maximum`
+ *   (inherited as `boolean | number` from `JsonSchemaCommon` for cross-draft compatibility).
+ * - No `const`, `contains`, `propertyNames`, `examples`, `if`/`then`/`else`.
+ *
+ * @see https://json-schema.org/draft-04/draft-zyp-json-schema-04
+ */
+interface JsonSchemaDraft4 extends JsonSchemaCommon {
+  /** Schema identifier (draft-04). Replaced by `$id` in draft-06+. */
+  id?: string;
+}
+/**
+ * JSON Schema Draft-06.
+ *
+ * Additions over Draft-04:
+ * - `$id` replaces `id`.
+ * - `exclusiveMinimum`/`exclusiveMaximum` changed to standalone `number` values.
+ * - Added `const`, `contains`, `propertyNames`, `examples`.
+ *
+ * @see https://json-schema.org/draft-06/draft-wright-json-schema-validation-01
+ */
+interface JsonSchemaDraft6 extends JsonSchemaCommon {
+  $id?: string;
+  const?: unknown;
+  contains?: JsonSchema;
+  propertyNames?: JsonSchema;
+  examples?: unknown[];
+}
+/**
+ * JSON Schema Draft-07.
+ *
+ * Additions over Draft-06:
+ * - `if`/`then`/`else` conditional applicators.
+ * - `contentEncoding`, `contentMediaType`.
+ *
+ * @see https://json-schema.org/draft-07/draft-handrews-json-schema-validation-01
+ */
+interface JsonSchemaDraft7 extends JsonSchemaDraft6 {
+  if?: JsonSchema | boolean;
+  then?: JsonSchema | boolean;
+  else?: JsonSchema | boolean;
+  contentEncoding?: string;
+  contentMediaType?: string;
+}
+/**
+ * JSON Schema Draft 2019-09.
+ *
+ * Additions over Draft-07:
+ * - `$defs` (replaces `definitions`), `$anchor`, `$vocabulary`.
+ * - `$recursiveAnchor`/`$recursiveRef` for recursive references.
+ * - `dependentSchemas`/`dependentRequired` (split from `dependencies`).
+ * - `unevaluatedItems`/`unevaluatedProperties`.
+ * - `maxContains`/`minContains`.
+ *
+ * @see https://json-schema.org/draft/2019-09/release-notes
+ */
+interface JsonSchemaDraft201909 extends JsonSchemaDraft7 {
+  $defs?: Record<string, JsonSchema>;
+  $anchor?: string;
+  $vocabulary?: Record<string, boolean>;
+  $recursiveAnchor?: boolean;
+  $recursiveRef?: string;
+  dependentSchemas?: Record<string, JsonSchema>;
+  dependentRequired?: Record<string, string[]>;
+  unevaluatedItems?: JsonSchema | boolean;
+  unevaluatedProperties?: JsonSchema | boolean;
+  maxContains?: number;
+  minContains?: number;
+}
+/**
+ * JSON Schema Draft 2020-12.
+ *
+ * Additions over Draft 2019-09:
+ * - `$dynamicAnchor`/`$dynamicRef` replace `$recursiveAnchor`/`$recursiveRef`.
+ * - `prefixItems` replaces the array form of `items`.
+ *
+ * @see https://json-schema.org/draft/2020-12/release-notes
+ */
+interface JsonSchemaDraft202012 extends JsonSchemaDraft201909 {
+  $dynamicAnchor?: string;
+  $dynamicRef?: string;
+  prefixItems?: Array<JsonSchema | boolean>;
+}
+//#endregion
+export { JsonSchema, JsonSchemaAll, JsonSchemaDraft201909, JsonSchemaDraft202012, JsonSchemaDraft4, JsonSchemaDraft6, JsonSchemaDraft7, JsonSchemaInternal, JsonSchemaVersion };

package/dist/json-schema-versions.mjs

@@ -0,0 +1,11 @@
+//#region src/json-schema-versions.ts
+const CURRENT_DEFAULT_SCHEMA_VERSION = "draft2020-12";
+const VERSION_SCHEMA_URL_MAPPING = {
+	"draft-04": "http://json-schema.org/draft-04/schema#",
+	"draft-06": "http://json-schema.org/draft-06/schema#",
+	"draft-07": "http://json-schema.org/draft-07/schema#",
+	"draft2019-09": "https://json-schema.org/draft/2019-09/schema",
+	"draft2020-12": "https://json-schema.org/draft/2020-12/schema"
+};
+//#endregion
+export { CURRENT_DEFAULT_SCHEMA_VERSION, VERSION_SCHEMA_URL_MAPPING };

package/dist/json-schema.d.mts

@@ -0,0 +1,61 @@
+import { ZSchemaOptions } from "./z-schema-options.mjs";
+import { Reference } from "./schema-compiler.mjs";
+import { JsonSchema, JsonSchemaInternal } from "./json-schema-versions.mjs";
+
+//#region src/json-schema.d.ts
+/**
+ * Properties present in ALL JSON Schema drafts (04 through 2020-12) with
+ * identical types.  Draft-specific additions live on the individual draft
+ * interfaces in `json-schema-versions.ts`.
+ */
+interface JsonSchemaCommon {
+  $ref?: string;
+  $schema?: string;
+  title?: string;
+  description?: string;
+  default?: unknown;
+  type?: string | string[];
+  enum?: Array<unknown>;
+  format?: string;
+  multipleOf?: number;
+  minimum?: number;
+  maximum?: number;
+  /** Draft-04: `boolean` modifier on `minimum`/`maximum`. Draft-06+: standalone `number`. */
+  exclusiveMinimum?: boolean | number;
+  /** Draft-04: `boolean` modifier on `minimum`/`maximum`. Draft-06+: standalone `number`. */
+  exclusiveMaximum?: boolean | number;
+  minLength?: number;
+  maxLength?: number;
+  pattern?: string;
+  items?: JsonSchema | boolean | Array<JsonSchema | boolean>;
+  additionalItems?: boolean | JsonSchema;
+  minItems?: number;
+  maxItems?: number;
+  uniqueItems?: boolean;
+  properties?: Record<string, JsonSchema | boolean>;
+  patternProperties?: Record<string, JsonSchema>;
+  additionalProperties?: boolean | JsonSchema;
+  required?: string[];
+  minProperties?: number;
+  maxProperties?: number;
+  dependencies?: Record<string, string[] | JsonSchema>;
+  allOf?: JsonSchema[];
+  anyOf?: JsonSchema[];
+  oneOf?: JsonSchema[];
+  not?: JsonSchema;
+  definitions?: Record<string, JsonSchema>;
+}
+type JsonSchemaType = 'array' | 'boolean' | 'integer' | 'null' | 'number' | 'object' | 'string';
+interface ZSchemaInternalProperties {
+  __$compiled?: unknown;
+  __$missingReferences?: Reference[];
+  __$refResolved?: JsonSchema;
+  __$dynamicRefResolved?: JsonSchema;
+  __$recursiveRefResolved?: JsonSchema;
+  __$resourceRoot?: JsonSchemaInternal;
+  __$schemaResolved?: unknown;
+  __$validated?: boolean;
+  __$validationOptions?: ZSchemaOptions;
+}
+//#endregion
+export { JsonSchemaCommon, JsonSchemaType, ZSchemaInternalProperties };