z-schema 12.0.4 → 12.1.0

package/dist/json-schema.mjs

@@ -0,0 +1,53 @@
+import { getRemotePath, isAbsoluteUri } from "./utils/uri.mjs";
+import { isObject } from "./utils/what-is.mjs";
+//#region src/json-schema.ts
+/**
+* Keywords whose values are not JSON Schema sub-schemas and must not be
+* traversed during schema walking (id collection, reference collection, etc.).
+*/
+const NON_SCHEMA_KEYWORDS = [
+	"enum",
+	"const",
+	"default",
+	"examples"
+];
+/** Returns true if the key is an internal z-schema property (prefixed with `__$`). */
+const isInternalKey = (key) => key.startsWith("__$");
+const getId = (schema) => {
+	if (typeof schema.$schema === "string" && schema.$schema.includes("draft-04")) return schema.id;
+	return schema.$id ?? schema.id;
+};
+const findId = (schema, id, targetBaseUri, currentBaseUri, maxDepth = 100, _depth = 0) => {
+	if (typeof schema !== "object" || schema === null) return;
+	if (!id) return schema;
+	if (_depth >= maxDepth) throw new Error(`Maximum recursion depth (${maxDepth}) exceeded in findId. If your schema is deeply nested and valid, increase the maxRecursionDepth option.`);
+	const baseUri = currentBaseUri ?? targetBaseUri;
+	const schemaId = getId(schema);
+	let nextBaseUri = baseUri;
+	if (schemaId) {
+		if (isAbsoluteUri(schemaId)) nextBaseUri = getRemotePath(schemaId);
+		else if (baseUri && isAbsoluteUri(baseUri)) try {
+			nextBaseUri = getRemotePath(new URL(schemaId, baseUri).toString());
+		} catch {}
+	}
+	if (!targetBaseUri || nextBaseUri === targetBaseUri) {
+		if (schemaId && (schemaId === id || schemaId[0] === "#" && schemaId.substring(1) === id)) return schema;
+		if (schema.$anchor === id || schema.$dynamicAnchor === id) return schema;
+	}
+	let result;
+	if (Array.isArray(schema)) for (let i = 0; i < schema.length; i++) {
+		result = findId(schema[i], id, targetBaseUri, nextBaseUri, maxDepth, _depth + 1);
+		if (result) return result;
+	}
+	if (isObject(schema)) {
+		const keys = Object.keys(schema);
+		for (let i = keys.length - 1; i >= 0; i--) {
+			const k = keys[i];
+			if (isInternalKey(k) || NON_SCHEMA_KEYWORDS.includes(k)) continue;
+			result = findId(schema[k], id, targetBaseUri, nextBaseUri, maxDepth, _depth + 1);
+			if (result) return result;
+		}
+	}
+};
+//#endregion
+export { NON_SCHEMA_KEYWORDS, findId, getId, isInternalKey };

package/dist/json-validation.mjs

@@ -0,0 +1,441 @@
+import { isObject, whatIs } from "./utils/what-is.mjs";
+import { getId } from "./json-schema.mjs";
+import { Report } from "./report.mjs";
+import { compileSchemaRegex } from "./utils/schema-regex.mjs";
+import { VALIDATION_VOCAB_KEYWORDS, getCachedValidationResult, isValidationVocabularyEnabled } from "./validation/shared.mjs";
+import { additionalItemsValidator, containsValidator, itemsValidator, maxContainsValidator, maxItemsValidator, minContainsValidator, minItemsValidator, prefixItemsValidator, uniqueItemsValidator } from "./validation/array.mjs";
+import { allOfValidator, anyOfValidator, elseValidator, ifValidator, notValidator, oneOfValidator, thenValidator } from "./validation/combinators.mjs";
+import { exclusiveMaximumValidator, exclusiveMinimumValidator, maximumValidator, minimumValidator, multipleOfValidator } from "./validation/numeric.mjs";
+import { additionalPropertiesValidator, dependenciesValidator, dependentRequiredValidator, dependentSchemasValidator, maxPropertiesValidator, minPropertiesValidator, patternPropertiesValidator, propertiesValidator, propertyNamesValidator, requiredValidator } from "./validation/object.mjs";
+import { resolveDynamicRef, resolveRecursiveRef } from "./validation/ref.mjs";
+import { contentEncodingValidator, contentMediaTypeValidator, formatValidator, maxLengthValidator, minLengthValidator, patternValidator } from "./validation/string.mjs";
+import { constValidator, enumValidator, typeValidator } from "./validation/type.mjs";
+//#region src/json-validation.ts
+function collectEvaluated(args) {
+	const { report, currentSchema, json, mode, depth } = args;
+	if (!currentSchema || typeof currentSchema === "boolean") return /* @__PURE__ */ new Set();
+	if (depth > (this.options.maxRecursionDepth ?? 100)) {
+		report.addError("COLLECT_EVALUATED_DEPTH_EXCEEDED", [depth]);
+		return /* @__PURE__ */ new Set();
+	}
+	const evaluated = /* @__PURE__ */ new Set();
+	const merge = (other) => {
+		if (other === "all") return true;
+		for (const v of other) evaluated.add(v);
+		return false;
+	};
+	const recurse = (subSchema) => {
+		if (mode === "items") return collectEvaluated.call(this, {
+			report,
+			currentSchema: subSchema,
+			json,
+			mode: "items",
+			jsonArr: args.jsonArr,
+			depth: depth + 1
+		});
+		return collectEvaluated.call(this, {
+			report,
+			currentSchema: subSchema,
+			json,
+			mode: "properties",
+			jsonData: args.jsonData,
+			depth: depth + 1
+		});
+	};
+	if (mode === "items") {
+		const jsonArr = args.jsonArr;
+		if (Array.isArray(currentSchema.prefixItems)) {
+			const len = Math.min(currentSchema.prefixItems.length, jsonArr.length);
+			for (let i = 0; i < len; i++) evaluated.add(i);
+		}
+		if (currentSchema.items !== void 0) {
+			if (Array.isArray(currentSchema.items)) {
+				const len = Math.min(currentSchema.items.length, jsonArr.length);
+				for (let i = 0; i < len; i++) evaluated.add(i);
+			} else if (currentSchema.items !== false) return "all";
+		}
+		if (currentSchema.additionalItems !== void 0 && currentSchema.additionalItems !== false && Array.isArray(currentSchema.items)) return "all";
+		if (currentSchema.contains !== void 0) for (let i = 0; i < jsonArr.length; i++) {
+			let passed = getCachedValidationResult(report, currentSchema.contains, jsonArr[i]);
+			if (passed === void 0) {
+				const subReport = new Report(report);
+				validate.call(this, subReport, currentSchema.contains, jsonArr[i]);
+				passed = subReport.errors.length === 0;
+			}
+			if (passed) evaluated.add(i);
+		}
+		if (currentSchema.unevaluatedItems === true) return "all";
+	} else {
+		const jsonData = args.jsonData;
+		if (isObject(currentSchema.properties)) {
+			for (const key of Object.keys(currentSchema.properties)) if (Object.hasOwn(jsonData, key)) evaluated.add(key);
+		}
+		if (isObject(currentSchema.patternProperties)) for (const pattern of Object.keys(currentSchema.patternProperties)) {
+			const result = compileSchemaRegex(pattern);
+			if (result.ok) {
+				for (const key of Object.keys(jsonData)) if (result.value.test(key)) evaluated.add(key);
+			}
+		}
+		if (currentSchema.additionalProperties !== void 0) {
+			const propKeys = isObject(currentSchema.properties) ? Object.keys(currentSchema.properties) : [];
+			const patternRegexes = [];
+			if (isObject(currentSchema.patternProperties)) for (const pattern of Object.keys(currentSchema.patternProperties)) {
+				const result = compileSchemaRegex(pattern);
+				if (result.ok) patternRegexes.push(result.value);
+			}
+			for (const key of Object.keys(jsonData)) {
+				if (propKeys.includes(key)) continue;
+				if (patternRegexes.some((re) => re.test(key))) continue;
+				evaluated.add(key);
+			}
+		}
+		if (isObject(currentSchema.dependentSchemas)) {
+			for (const [depKey, depSchema] of Object.entries(currentSchema.dependentSchemas)) if (Object.hasOwn(jsonData, depKey)) {
+				if (merge(recurse(depSchema))) return "all";
+			}
+		}
+		if (currentSchema.unevaluatedProperties === true) return "all";
+	}
+	if (Array.isArray(currentSchema.allOf)) {
+		for (const subSchema of currentSchema.allOf) if (merge(recurse(subSchema))) return "all";
+	}
+	if (Array.isArray(currentSchema.anyOf)) for (const subSchema of currentSchema.anyOf) {
+		let passed = getCachedValidationResult(report, subSchema, json);
+		if (passed === void 0) {
+			const subReport = new Report(report);
+			validate.call(this, subReport, subSchema, json);
+			passed = subReport.errors.length === 0;
+		}
+		if (passed) {
+			if (merge(recurse(subSchema))) return "all";
+		}
+	}
+	if (Array.isArray(currentSchema.oneOf)) for (const subSchema of currentSchema.oneOf) {
+		let passed = getCachedValidationResult(report, subSchema, json);
+		if (passed === void 0) {
+			const subReport = new Report(report);
+			validate.call(this, subReport, subSchema, json);
+			passed = subReport.errors.length === 0;
+		}
+		if (passed) {
+			if (merge(recurse(subSchema))) return "all";
+		}
+	}
+	if (currentSchema.if !== void 0) {
+		let condPassed = getCachedValidationResult(report, currentSchema.if, json);
+		if (condPassed === void 0) {
+			const condReport = new Report(report);
+			validate.call(this, condReport, currentSchema.if, json);
+			condPassed = condReport.errors.length === 0;
+		}
+		if (condPassed) {
+			if (merge(recurse(currentSchema.if))) return "all";
+			if (currentSchema.then !== void 0) {
+				if (merge(recurse(currentSchema.then))) return "all";
+			}
+		} else if (currentSchema.else !== void 0) {
+			if (merge(recurse(currentSchema.else))) return "all";
+		}
+	}
+	if (currentSchema.__$refResolved && currentSchema.__$refResolved !== currentSchema) {
+		if (merge(recurse(currentSchema.__$refResolved))) return "all";
+	}
+	const recursiveTarget = resolveRecursiveRef(currentSchema, report.__$recursiveAnchorStack);
+	if (recursiveTarget && recursiveTarget !== currentSchema) {
+		if (merge(recurse(recursiveTarget))) return "all";
+	}
+	const dynamicTarget = resolveDynamicRef(currentSchema, report.__$dynamicScopeStack);
+	if (dynamicTarget && dynamicTarget !== currentSchema) {
+		if (merge(recurse(dynamicTarget))) return "all";
+	}
+	return evaluated;
+}
+function unevaluatedItemsValidator(report, schema, json) {
+	if (!Array.isArray(json)) return;
+	if (schema.unevaluatedItems === true) return;
+	const unevalSchema = schema.unevaluatedItems;
+	if (unevalSchema === void 0) return;
+	if (json.length === 0) return;
+	const evaluatedItems = collectEvaluated.call(this, {
+		report,
+		currentSchema: schema,
+		json,
+		mode: "items",
+		jsonArr: json,
+		depth: 0
+	});
+	if (evaluatedItems === "all") return;
+	const unevaluatedIndices = [];
+	for (let i = 0; i < json.length; i++) if (!evaluatedItems.has(i)) unevaluatedIndices.push(i);
+	if (unevaluatedIndices.length === 0) return;
+	if (unevalSchema === false) report.addError("ARRAY_UNEVALUATED_ITEMS", void 0, void 0, schema, "unevaluatedItems");
+	else for (const idx of unevaluatedIndices) {
+		const subReport = new Report(report);
+		validate.call(this, subReport, unevalSchema, json[idx]);
+		if (subReport.errors.length > 0) {
+			report.addError("ARRAY_UNEVALUATED_ITEMS", void 0, void 0, schema, "unevaluatedItems");
+			break;
+		}
+	}
+}
+function unevaluatedPropertiesValidator(report, schema, json) {
+	if (!isObject(json)) return;
+	if (schema.unevaluatedProperties === true) return;
+	const unevalSchema = schema.unevaluatedProperties;
+	if (unevalSchema === void 0) return;
+	const allKeys = Object.keys(json);
+	if (allKeys.length === 0) return;
+	const evaluatedProperties = collectEvaluated.call(this, {
+		report,
+		currentSchema: schema,
+		json,
+		mode: "properties",
+		jsonData: json,
+		depth: 0
+	});
+	if (evaluatedProperties === "all") return;
+	const unevaluatedKeys = allKeys.filter((key) => !evaluatedProperties.has(key));
+	if (unevaluatedKeys.length === 0) return;
+	if (unevalSchema === false) report.addError("OBJECT_UNEVALUATED_PROPERTIES", [unevaluatedKeys.join(", ")], void 0, schema, "unevaluatedProperties");
+	else for (const key of unevaluatedKeys) {
+		const subReport = new Report(report);
+		validate.call(this, subReport, unevalSchema, json[key]);
+		if (subReport.errors.length > 0) report.addError("OBJECT_UNEVALUATED_PROPERTIES", [key], void 0, schema, "unevaluatedProperties");
+	}
+}
+function definitionsValidator() {}
+const JsonValidators = {
+	id: () => {},
+	$id: () => {},
+	$ref: () => {},
+	$schema: () => {},
+	$dynamicAnchor: () => {},
+	$dynamicRef: () => {},
+	$anchor: () => {},
+	$defs: () => {},
+	$vocabulary: () => {},
+	$recursiveAnchor: () => {},
+	$recursiveRef: () => {},
+	examples: () => {},
+	title: () => {},
+	description: () => {},
+	default: () => {},
+	type: typeValidator,
+	enum: enumValidator,
+	const: constValidator,
+	multipleOf: multipleOfValidator,
+	maximum: maximumValidator,
+	exclusiveMaximum: exclusiveMaximumValidator,
+	minimum: minimumValidator,
+	exclusiveMinimum: exclusiveMinimumValidator,
+	maxLength: maxLengthValidator,
+	minLength: minLengthValidator,
+	pattern: patternValidator,
+	format: formatValidator,
+	contentEncoding: contentEncodingValidator,
+	contentMediaType: contentMediaTypeValidator,
+	additionalItems: additionalItemsValidator,
+	items: itemsValidator,
+	prefixItems: prefixItemsValidator,
+	maxItems: maxItemsValidator,
+	minItems: minItemsValidator,
+	uniqueItems: uniqueItemsValidator,
+	contains: containsValidator,
+	maxContains: maxContainsValidator,
+	minContains: minContainsValidator,
+	unevaluatedItems: unevaluatedItemsValidator,
+	maxProperties: maxPropertiesValidator,
+	minProperties: minPropertiesValidator,
+	required: requiredValidator,
+	additionalProperties: additionalPropertiesValidator,
+	patternProperties: patternPropertiesValidator,
+	properties: propertiesValidator,
+	dependencies: dependenciesValidator,
+	dependentSchemas: dependentSchemasValidator,
+	dependentRequired: dependentRequiredValidator,
+	propertyNames: propertyNamesValidator,
+	unevaluatedProperties: unevaluatedPropertiesValidator,
+	allOf: allOfValidator,
+	anyOf: anyOfValidator,
+	oneOf: oneOfValidator,
+	not: notValidator,
+	if: ifValidator,
+	then: thenValidator,
+	else: elseValidator,
+	definitions: definitionsValidator
+};
+const recurseArray = function(report, schema, json) {
+	const schemaUri = typeof schema.$schema === "string" ? schema.$schema : void 0;
+	const prefixItems = (schemaUri === "https://json-schema.org/draft/2020-12/schema" || !schemaUri && this.options.version === "draft2020-12") && Array.isArray(schema.prefixItems) ? schema.prefixItems : void 0;
+	if (prefixItems) {
+		for (let idx = 0; idx < json.length; idx++) if (idx < prefixItems.length) {
+			report.path.push(idx);
+			validate.call(this, report, prefixItems[idx], json[idx]);
+			report.path.pop();
+		} else if (schema.items !== void 0 && !Array.isArray(schema.items)) {
+			report.path.push(idx);
+			report.schemaPath.push("items");
+			validate.call(this, report, schema.items, json[idx]);
+			report.schemaPath.pop();
+			report.path.pop();
+		}
+		return;
+	}
+	if (Array.isArray(schema.items)) {
+		for (let idx = 0; idx < json.length; idx++) if (idx < schema.items.length) {
+			report.path.push(idx);
+			validate.call(this, report, schema.items[idx], json[idx]);
+			report.path.pop();
+		} else if (typeof schema.additionalItems === "object") {
+			report.path.push(idx);
+			validate.call(this, report, schema.additionalItems, json[idx]);
+			report.path.pop();
+		}
+	} else if (typeof schema.items === "object" || typeof schema.items === "boolean") for (let idx = 0; idx < json.length; idx++) {
+		report.path.push(idx);
+		report.schemaPath.push("items");
+		validate.call(this, report, schema.items, json[idx]);
+		report.schemaPath.pop();
+		report.path.pop();
+	}
+};
+const recurseObject = function(report, schema, json) {
+	let additionalProperties = schema.additionalProperties;
+	if (additionalProperties === true || additionalProperties === void 0) additionalProperties = {};
+	const p = schema.properties ? Object.keys(schema.properties) : [];
+	const pp = schema.patternProperties ? Object.keys(schema.patternProperties) : [];
+	const keys = Object.keys(json);
+	for (const m of keys) {
+		const propertyValue = json[m];
+		const s = [];
+		if (p.includes(m)) s.push(schema.properties[m]);
+		for (const regexString of pp) {
+			const result = compileSchemaRegex(regexString);
+			if (result.ok && result.value.test(m) === true) s.push(schema.patternProperties[regexString]);
+		}
+		if (s.length === 0 && additionalProperties !== false) s.push(additionalProperties);
+		for (const schema_s of s) {
+			report.path.push(m);
+			if (p.includes(m)) {
+				report.schemaPath.push("properties");
+				report.schemaPath.push(m);
+			} else report.schemaPath.push("additionalProperties");
+			validate.call(this, report, schema_s, propertyValue);
+			report.path.pop();
+			report.schemaPath.pop();
+			if (p.includes(m)) report.schemaPath.pop();
+		}
+	}
+};
+function validate(report, schema, json) {
+	report.commonErrorMessage = "JSON_OBJECT_VALIDATION_FAILED";
+	if (schema === true) return true;
+	if (schema === false) {
+		report.addError("SCHEMA_IS_FALSE", [], void 0, schema);
+		return false;
+	}
+	if (!isObject(schema)) {
+		report.addError("SCHEMA_NOT_AN_OBJECT", [whatIs(schema)], void 0, schema);
+		return false;
+	}
+	let keys = Object.keys(schema);
+	if (keys.length === 0) return true;
+	let isRoot = false;
+	if (!report.rootSchema) {
+		report.rootSchema = schema;
+		isRoot = true;
+	}
+	const recursiveAnchorStack = report.__$recursiveAnchorStack;
+	const dynamicScopeStack = report.__$dynamicScopeStack;
+	let pushedRecursiveAnchor = false;
+	let pushedDynamicScope = false;
+	const schemaId = getId(schema);
+	const dynamicScopeEntry = schema.__$resourceRoot || (isRoot || typeof schemaId === "string" ? schema : void 0);
+	if (dynamicScopeEntry && dynamicScopeStack[dynamicScopeStack.length - 1] !== dynamicScopeEntry) {
+		dynamicScopeStack.push(dynamicScopeEntry);
+		pushedDynamicScope = true;
+	}
+	if (schema.$recursiveAnchor === true) {
+		recursiveAnchorStack.push(schema);
+		pushedRecursiveAnchor = true;
+	}
+	if (schema.$ref !== void 0) if (this.options.version === "draft2019-09" || this.options.version === "draft2020-12") {
+		if (!schema.__$refResolved) report.addError("REF_UNRESOLVED", [schema.$ref], void 0, schema);
+		else validate.call(this, report, schema.__$refResolved, json);
+		keys = keys.filter((key) => key !== "$ref");
+	} else {
+		let maxRefs = 99;
+		while (schema.$ref && maxRefs > 0) {
+			if (!schema.__$refResolved) {
+				report.addError("REF_UNRESOLVED", [schema.$ref], void 0, schema);
+				break;
+			} else if (schema.__$refResolved === schema) break;
+			else {
+				schema = schema.__$refResolved;
+				keys = Object.keys(schema);
+			}
+			maxRefs--;
+		}
+		if (maxRefs === 0) throw new Error("Circular dependency by $ref references!");
+		report.schemaPath = [];
+	}
+	if (schema.$recursiveRef !== void 0) {
+		if (this.options.version === "draft2019-09" || this.options.version === "draft2020-12") {
+			const recursiveRefTarget = resolveRecursiveRef(schema, recursiveAnchorStack);
+			if (!recursiveRefTarget) report.addError("REF_UNRESOLVED", [schema.$recursiveRef], void 0, schema);
+			else validate.call(this, report, recursiveRefTarget, json);
+			keys = keys.filter((key) => key !== "$recursiveRef");
+		}
+	}
+	if (schema.$dynamicRef !== void 0) {
+		if (this.options.version === "draft2020-12") {
+			const dynamicRefTarget = resolveDynamicRef(schema, dynamicScopeStack);
+			if (typeof dynamicRefTarget === "undefined") report.addError("REF_UNRESOLVED", [schema.$dynamicRef], void 0, schema);
+			else validate.call(this, report, dynamicRefTarget, json);
+			keys = keys.filter((key) => key !== "$dynamicRef");
+		}
+	}
+	const validationVocabularyEnabled = isValidationVocabularyEnabled(schema, report, this.options.version);
+	if (!validationVocabularyEnabled) keys = keys.filter((key) => !VALIDATION_VOCAB_KEYWORDS.has(key));
+	if (validationVocabularyEnabled && schema.type) {
+		keys.splice(keys.indexOf("type"), 1);
+		report.schemaPath.push("type");
+		JsonValidators.type.call(this, report, schema, json);
+		report.schemaPath.pop();
+		if (report.errors.length && this.options.breakOnFirstError) {
+			if (pushedRecursiveAnchor) recursiveAnchorStack.pop();
+			if (pushedDynamicScope) dynamicScopeStack.pop();
+			return false;
+		}
+	}
+	const deferredUnevaluatedKeys = [];
+	for (const key of keys) {
+		if (key === "unevaluatedItems" || key === "unevaluatedProperties") {
+			deferredUnevaluatedKeys.push(key);
+			continue;
+		}
+		const validator = JsonValidators[key];
+		if (validator) {
+			validator.call(this, report, schema, json);
+			if (report.errors.length && this.options.breakOnFirstError) break;
+		}
+	}
+	if (deferredUnevaluatedKeys.length > 0 && !(report.errors.length > 0 && this.options.breakOnFirstError)) for (const key of deferredUnevaluatedKeys) {
+		const validator = JsonValidators[key];
+		if (validator) {
+			validator.call(this, report, schema, json);
+			if (report.errors.length && this.options.breakOnFirstError) break;
+		}
+	}
+	if (report.errors.length === 0 || this.options.breakOnFirstError === false) {
+		if (Array.isArray(json)) recurseArray.call(this, report, schema, json);
+		else if (isObject(json)) recurseObject.call(this, report, schema, json);
+	}
+	if (typeof this.options.customValidator === "function") this.options.customValidator.call(this, report, schema, json);
+	if (pushedRecursiveAnchor) recursiveAnchorStack.pop();
+	if (pushedDynamicScope) dynamicScopeStack.pop();
+	if (isRoot) report.rootSchema = void 0;
+	return report.errors.length === 0;
+}
+//#endregion
+export { validate };

package/dist/report.d.mts

@@ -0,0 +1,97 @@
+import { ZSchemaOptions } from "./z-schema-options.mjs";
+import { ErrorCode, ErrorParam } from "./errors.mjs";
+import { ValidateCallback, ValidateOptions } from "./z-schema-base.mjs";
+import { JsonSchema, JsonSchemaAll, JsonSchemaInternal } from "./json-schema-versions.mjs";
+
+//#region src/report.d.ts
+interface SchemaErrorDetail {
+  /**
+   * Example: "Expected type string but found type array"
+   */
+  message: string;
+  /**
+   * An error identifier that can be used to format a custom error message.
+   * Example: "INVALID_TYPE"
+   */
+  code: string;
+  /**
+   * Format parameters that can be used to format a custom error message.
+   * Example: ["string","array"]
+   */
+  params: ErrorParam[];
+  /**
+   * A JSON path indicating the location of the error.
+   * Example: "#/projects/1"
+   */
+  path: string | Array<string | number>;
+  /**
+   * A JSON path indicating the location in the schema where the constraint is defined.
+   * Example: ["properties", "name", "type"]
+   */
+  schemaPath?: Array<string | number>;
+  /**
+   * The schema rule description, which is included for certain errors where
+   * this information is useful (e.g. to describe a constraint).
+   */
+  title?: string;
+  description?: string;
+  /**
+   * Returns details for sub-schemas that failed to match.  For example, if the schema
+   * uses the "oneOf" constraint to accept several alternative possibilities, each
+   * alternative will have its own inner detail object explaining why it failed to match.
+   */
+  inner?: SchemaErrorDetail[];
+  schemaId?: string;
+  /**
+   * The schema keyword that caused this validation error.
+   * Example: "required", "type", "minLength"
+   */
+  keyword?: keyof JsonSchemaAll;
+}
+interface ReportOptions {
+  maxErrors?: number;
+}
+type TaskResult = unknown;
+type TaskFn = (...args: unknown[]) => TaskResult;
+type TaskFnArgs = Parameters<TaskFn>;
+type TaskProcessFn = (result: ReturnType<TaskFn>) => void;
+type AsyncTask = [TaskFn, TaskFnArgs, TaskProcessFn];
+declare class Report {
+  asyncTasks: AsyncTask[];
+  commonErrorMessage?: string;
+  __$recursiveAnchorStack: JsonSchemaInternal[];
+  __$dynamicScopeStack: JsonSchemaInternal[];
+  __validationResultCache: Map<unknown, Map<unknown, boolean>>;
+  errors: SchemaErrorDetail[];
+  json?: unknown;
+  path: Array<number | string>;
+  schemaPath: Array<number | string>;
+  rootSchema?: JsonSchemaInternal;
+  parentReport?: Report;
+  options: ZSchemaOptions;
+  reportOptions: ReportOptions;
+  validateOptions: ValidateOptions;
+  constructor(zschemaOptions: ZSchemaOptions, validateOptions?: ValidateOptions);
+  constructor(parentReport: Report, validateOptions?: ValidateOptions);
+  constructor(parentReport: Report, reportOptions: ReportOptions, validateOptions?: ValidateOptions);
+  isValid(): boolean;
+  addAsyncTask<FV, FN extends (...args: any[]) => FV>(fn: FN, args: Parameters<FN>, asyncTaskResultProcessFn: (result: ReturnType<FN>) => void): void;
+  /**
+   * Like {@link addAsyncTask}, but automatically saves the current `path` and
+   * restores it around `processFn`.  This eliminates the manual
+   * path-save/restore boilerplate that every async-aware validator would
+   * otherwise need.
+   */
+  addAsyncTaskWithPath(fn: (...args: any[]) => any, args: any[], processFn: (result: any) => void): void;
+  getAncestor(id: string): Report | undefined;
+  processAsyncTasks(timeout: number | undefined, callback: ValidateCallback): void;
+  getPath(returnPathAsString?: boolean): string | (string | number)[];
+  getSchemaPath(): Array<string | number>;
+  getSchemaId(): string | undefined;
+  hasError(errCode: string, errParams: Array<any>): boolean;
+  addError(errCode: ErrorCode, errParams?: ErrorParam[], subReports?: Report | Report[], schema?: JsonSchema | boolean, keyword?: keyof JsonSchemaAll): void;
+  getJson(): unknown;
+  addCustomError(errorCode: ErrorCode, errorMessage: string, params?: ErrorParam[], subReports?: Report | Report[], schema?: JsonSchema | boolean, keyword?: keyof JsonSchemaAll): void;
+}
+//#endregion
+export { Report, SchemaErrorDetail };