oatschema 0.0.1 → 0.1.0

package/dist/validate/classification.d.ts

@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: 2026 The OATS Authors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Validation of records against the `classification` OATS schema only, with precompiled validators.
+ *
+ * @module
+ */
+
+import type { SchemaVersion } from "../names.js";
+import type { ValidateOptions, Validator } from "../validation.js";
+
+export { SchemaLookupError } from "../errors.js";
+export { ValidationError, type ValidationErrorDetails, type ValidateOptions, type Validator } from "../validation.js";
+
+/**
+ * Return a cached {@link Validator} for the `classification` schema in schema version `version`, or in
+ * `SCHEMA_VERSION` if `version` is omitted.
+ *
+ * Formats (`date-time`, `uri`, …) are checked unless `options.checkFormats` is `false`.
+ *
+ * @param version An exact bundled version such as `"0.8.0"`.
+ * @param options Validation options.
+ * @throws {SchemaLookupError} `version` is not bundled, or does not contain `classification`.
+ * @throws {TypeError} `options` is not an object, has an unknown key, or `checkFormats` is not a boolean.
+ */
+export declare function getValidator(version?: SchemaVersion, options?: ValidateOptions): Validator;

package/dist/validate/classification.js

@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: 2026 The OATS Authors
+// SPDX-License-Identifier: Apache-2.0
+
+import v0 from "../compiled/0.8.0/classification.js";
+import { versionValidator } from "../validation.js";
+
+export { SchemaLookupError } from "../errors.js";
+export { ValidationError } from "../validation.js";
+
+const VERSIONS = new Map([["0.8.0", v0]]);
+
+export function getValidator(version, options) {
+  return versionValidator("classification", VERSIONS, version, options);
+}

package/dist/validate/document-extraction.d.ts

@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: 2026 The OATS Authors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Validation of records against the `document-extraction` OATS schema only, with precompiled validators.
+ *
+ * @module
+ */
+
+import type { SchemaVersion } from "../names.js";
+import type { ValidateOptions, Validator } from "../validation.js";
+
+export { SchemaLookupError } from "../errors.js";
+export { ValidationError, type ValidationErrorDetails, type ValidateOptions, type Validator } from "../validation.js";
+
+/**
+ * Return a cached {@link Validator} for the `document-extraction` schema in schema version `version`, or in
+ * `SCHEMA_VERSION` if `version` is omitted.
+ *
+ * Formats (`date-time`, `uri`, …) are checked unless `options.checkFormats` is `false`.
+ *
+ * @param version An exact bundled version such as `"0.8.0"`.
+ * @param options Validation options.
+ * @throws {SchemaLookupError} `version` is not bundled, or does not contain `document-extraction`.
+ * @throws {TypeError} `options` is not an object, has an unknown key, or `checkFormats` is not a boolean.
+ */
+export declare function getValidator(version?: SchemaVersion, options?: ValidateOptions): Validator;

package/dist/validate/document-extraction.js

@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: 2026 The OATS Authors
+// SPDX-License-Identifier: Apache-2.0
+
+import v0 from "../compiled/0.8.0/document-extraction.js";
+import { versionValidator } from "../validation.js";
+
+export { SchemaLookupError } from "../errors.js";
+export { ValidationError } from "../validation.js";
+
+const VERSIONS = new Map([["0.8.0", v0]]);
+
+export function getValidator(version, options) {
+  return versionValidator("document-extraction", VERSIONS, version, options);
+}

package/dist/validate/embedding.d.ts

@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: 2026 The OATS Authors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Validation of records against the `embedding` OATS schema only, with precompiled validators.
+ *
+ * @module
+ */
+
+import type { SchemaVersion } from "../names.js";
+import type { ValidateOptions, Validator } from "../validation.js";
+
+export { SchemaLookupError } from "../errors.js";
+export { ValidationError, type ValidationErrorDetails, type ValidateOptions, type Validator } from "../validation.js";
+
+/**
+ * Return a cached {@link Validator} for the `embedding` schema in schema version `version`, or in
+ * `SCHEMA_VERSION` if `version` is omitted.
+ *
+ * Formats (`date-time`, `uri`, …) are checked unless `options.checkFormats` is `false`.
+ *
+ * @param version An exact bundled version such as `"0.8.0"`.
+ * @param options Validation options.
+ * @throws {SchemaLookupError} `version` is not bundled, or does not contain `embedding`.
+ * @throws {TypeError} `options` is not an object, has an unknown key, or `checkFormats` is not a boolean.
+ */
+export declare function getValidator(version?: SchemaVersion, options?: ValidateOptions): Validator;

package/dist/validate/embedding.js

@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: 2026 The OATS Authors
+// SPDX-License-Identifier: Apache-2.0
+
+import v0 from "../compiled/0.8.0/embedding.js";
+import { versionValidator } from "../validation.js";
+
+export { SchemaLookupError } from "../errors.js";
+export { ValidationError } from "../validation.js";
+
+const VERSIONS = new Map([["0.8.0", v0]]);
+
+export function getValidator(version, options) {
+  return versionValidator("embedding", VERSIONS, version, options);
+}

package/dist/validate/entity-extraction.d.ts

@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: 2026 The OATS Authors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Validation of records against the `entity-extraction` OATS schema only, with precompiled validators.
+ *
+ * @module
+ */
+
+import type { SchemaVersion } from "../names.js";
+import type { ValidateOptions, Validator } from "../validation.js";
+
+export { SchemaLookupError } from "../errors.js";
+export { ValidationError, type ValidationErrorDetails, type ValidateOptions, type Validator } from "../validation.js";
+
+/**
+ * Return a cached {@link Validator} for the `entity-extraction` schema in schema version `version`, or in
+ * `SCHEMA_VERSION` if `version` is omitted.
+ *
+ * Formats (`date-time`, `uri`, …) are checked unless `options.checkFormats` is `false`.
+ *
+ * @param version An exact bundled version such as `"0.8.0"`.
+ * @param options Validation options.
+ * @throws {SchemaLookupError} `version` is not bundled, or does not contain `entity-extraction`.
+ * @throws {TypeError} `options` is not an object, has an unknown key, or `checkFormats` is not a boolean.
+ */
+export declare function getValidator(version?: SchemaVersion, options?: ValidateOptions): Validator;

package/dist/validate/entity-extraction.js

@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: 2026 The OATS Authors
+// SPDX-License-Identifier: Apache-2.0
+
+import v0 from "../compiled/0.8.0/entity-extraction.js";
+import { versionValidator } from "../validation.js";
+
+export { SchemaLookupError } from "../errors.js";
+export { ValidationError } from "../validation.js";
+
+const VERSIONS = new Map([["0.8.0", v0]]);
+
+export function getValidator(version, options) {
+  return versionValidator("entity-extraction", VERSIONS, version, options);
+}

package/dist/validate/generic.d.ts

@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: 2026 The OATS Authors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Validation of records against the `generic` OATS schema only, with precompiled validators.
+ *
+ * @module
+ */
+
+import type { SchemaVersion } from "../names.js";
+import type { ValidateOptions, Validator } from "../validation.js";
+
+export { SchemaLookupError } from "../errors.js";
+export { ValidationError, type ValidationErrorDetails, type ValidateOptions, type Validator } from "../validation.js";
+
+/**
+ * Return a cached {@link Validator} for the `generic` schema in schema version `version`, or in
+ * `SCHEMA_VERSION` if `version` is omitted.
+ *
+ * Formats (`date-time`, `uri`, …) are checked unless `options.checkFormats` is `false`.
+ *
+ * @param version An exact bundled version such as `"0.8.0"`.
+ * @param options Validation options.
+ * @throws {SchemaLookupError} `version` is not bundled, or does not contain `generic`.
+ * @throws {TypeError} `options` is not an object, has an unknown key, or `checkFormats` is not a boolean.
+ */
+export declare function getValidator(version?: SchemaVersion, options?: ValidateOptions): Validator;

package/dist/validate/generic.js

@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: 2026 The OATS Authors
+// SPDX-License-Identifier: Apache-2.0
+
+import v0 from "../compiled/0.8.0/generic.js";
+import { versionValidator } from "../validation.js";
+
+export { SchemaLookupError } from "../errors.js";
+export { ValidationError } from "../validation.js";
+
+const VERSIONS = new Map([["0.8.0", v0]]);
+
+export function getValidator(version, options) {
+  return versionValidator("generic", VERSIONS, version, options);
+}

package/dist/validate/geolocation.d.ts

@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: 2026 The OATS Authors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Validation of records against the `geolocation` OATS schema only, with precompiled validators.
+ *
+ * @module
+ */
+
+import type { SchemaVersion } from "../names.js";
+import type { ValidateOptions, Validator } from "../validation.js";
+
+export { SchemaLookupError } from "../errors.js";
+export { ValidationError, type ValidationErrorDetails, type ValidateOptions, type Validator } from "../validation.js";
+
+/**
+ * Return a cached {@link Validator} for the `geolocation` schema in schema version `version`, or in
+ * `SCHEMA_VERSION` if `version` is omitted.
+ *
+ * Formats (`date-time`, `uri`, …) are checked unless `options.checkFormats` is `false`.
+ *
+ * @param version An exact bundled version such as `"0.8.0"`.
+ * @param options Validation options.
+ * @throws {SchemaLookupError} `version` is not bundled, or does not contain `geolocation`.
+ * @throws {TypeError} `options` is not an object, has an unknown key, or `checkFormats` is not a boolean.
+ */
+export declare function getValidator(version?: SchemaVersion, options?: ValidateOptions): Validator;

package/dist/validate/geolocation.js

@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: 2026 The OATS Authors
+// SPDX-License-Identifier: Apache-2.0
+
+import v0 from "../compiled/0.8.0/geolocation.js";
+import { versionValidator } from "../validation.js";
+
+export { SchemaLookupError } from "../errors.js";
+export { ValidationError } from "../validation.js";
+
+const VERSIONS = new Map([["0.8.0", v0]]);
+
+export function getValidator(version, options) {
+  return versionValidator("geolocation", VERSIONS, version, options);
+}

package/dist/validate/llm-output.d.ts

@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: 2026 The OATS Authors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Validation of records against the `llm-output` OATS schema only, with precompiled validators.
+ *
+ * @module
+ */
+
+import type { SchemaVersion } from "../names.js";
+import type { ValidateOptions, Validator } from "../validation.js";
+
+export { SchemaLookupError } from "../errors.js";
+export { ValidationError, type ValidationErrorDetails, type ValidateOptions, type Validator } from "../validation.js";
+
+/**
+ * Return a cached {@link Validator} for the `llm-output` schema in schema version `version`, or in
+ * `SCHEMA_VERSION` if `version` is omitted.
+ *
+ * Formats (`date-time`, `uri`, …) are checked unless `options.checkFormats` is `false`.
+ *
+ * @param version An exact bundled version such as `"0.8.0"`.
+ * @param options Validation options.
+ * @throws {SchemaLookupError} `version` is not bundled, or does not contain `llm-output`.
+ * @throws {TypeError} `options` is not an object, has an unknown key, or `checkFormats` is not a boolean.
+ */
+export declare function getValidator(version?: SchemaVersion, options?: ValidateOptions): Validator;

package/dist/validate/llm-output.js

@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: 2026 The OATS Authors
+// SPDX-License-Identifier: Apache-2.0
+
+import v0 from "../compiled/0.8.0/llm-output.js";
+import { versionValidator } from "../validation.js";
+
+export { SchemaLookupError } from "../errors.js";
+export { ValidationError } from "../validation.js";
+
+const VERSIONS = new Map([["0.8.0", v0]]);
+
+export function getValidator(version, options) {
+  return versionValidator("llm-output", VERSIONS, version, options);
+}

package/dist/validate/object-detection.d.ts

@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: 2026 The OATS Authors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Validation of records against the `object-detection` OATS schema only, with precompiled validators.
+ *
+ * @module
+ */
+
+import type { SchemaVersion } from "../names.js";
+import type { ValidateOptions, Validator } from "../validation.js";
+
+export { SchemaLookupError } from "../errors.js";
+export { ValidationError, type ValidationErrorDetails, type ValidateOptions, type Validator } from "../validation.js";
+
+/**
+ * Return a cached {@link Validator} for the `object-detection` schema in schema version `version`, or in
+ * `SCHEMA_VERSION` if `version` is omitted.
+ *
+ * Formats (`date-time`, `uri`, …) are checked unless `options.checkFormats` is `false`.
+ *
+ * @param version An exact bundled version such as `"0.8.0"`.
+ * @param options Validation options.
+ * @throws {SchemaLookupError} `version` is not bundled, or does not contain `object-detection`.
+ * @throws {TypeError} `options` is not an object, has an unknown key, or `checkFormats` is not a boolean.
+ */
+export declare function getValidator(version?: SchemaVersion, options?: ValidateOptions): Validator;

package/dist/validate/object-detection.js

@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: 2026 The OATS Authors
+// SPDX-License-Identifier: Apache-2.0
+
+import v0 from "../compiled/0.8.0/object-detection.js";
+import { versionValidator } from "../validation.js";
+
+export { SchemaLookupError } from "../errors.js";
+export { ValidationError } from "../validation.js";
+
+const VERSIONS = new Map([["0.8.0", v0]]);
+
+export function getValidator(version, options) {
+  return versionValidator("object-detection", VERSIONS, version, options);
+}

package/dist/validate/ranking.d.ts

@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: 2026 The OATS Authors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Validation of records against the `ranking` OATS schema only, with precompiled validators.
+ *
+ * @module
+ */
+
+import type { SchemaVersion } from "../names.js";
+import type { ValidateOptions, Validator } from "../validation.js";
+
+export { SchemaLookupError } from "../errors.js";
+export { ValidationError, type ValidationErrorDetails, type ValidateOptions, type Validator } from "../validation.js";
+
+/**
+ * Return a cached {@link Validator} for the `ranking` schema in schema version `version`, or in
+ * `SCHEMA_VERSION` if `version` is omitted.
+ *
+ * Formats (`date-time`, `uri`, …) are checked unless `options.checkFormats` is `false`.
+ *
+ * @param version An exact bundled version such as `"0.8.0"`.
+ * @param options Validation options.
+ * @throws {SchemaLookupError} `version` is not bundled, or does not contain `ranking`.
+ * @throws {TypeError} `options` is not an object, has an unknown key, or `checkFormats` is not a boolean.
+ */
+export declare function getValidator(version?: SchemaVersion, options?: ValidateOptions): Validator;

package/dist/validate/ranking.js

@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: 2026 The OATS Authors
+// SPDX-License-Identifier: Apache-2.0
+
+import v0 from "../compiled/0.8.0/ranking.js";
+import { versionValidator } from "../validation.js";
+
+export { SchemaLookupError } from "../errors.js";
+export { ValidationError } from "../validation.js";
+
+const VERSIONS = new Map([["0.8.0", v0]]);
+
+export function getValidator(version, options) {
+  return versionValidator("ranking", VERSIONS, version, options);
+}

package/dist/validate/regression.d.ts

@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: 2026 The OATS Authors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Validation of records against the `regression` OATS schema only, with precompiled validators.
+ *
+ * @module
+ */
+
+import type { SchemaVersion } from "../names.js";
+import type { ValidateOptions, Validator } from "../validation.js";
+
+export { SchemaLookupError } from "../errors.js";
+export { ValidationError, type ValidationErrorDetails, type ValidateOptions, type Validator } from "../validation.js";
+
+/**
+ * Return a cached {@link Validator} for the `regression` schema in schema version `version`, or in
+ * `SCHEMA_VERSION` if `version` is omitted.
+ *
+ * Formats (`date-time`, `uri`, …) are checked unless `options.checkFormats` is `false`.
+ *
+ * @param version An exact bundled version such as `"0.8.0"`.
+ * @param options Validation options.
+ * @throws {SchemaLookupError} `version` is not bundled, or does not contain `regression`.
+ * @throws {TypeError} `options` is not an object, has an unknown key, or `checkFormats` is not a boolean.
+ */
+export declare function getValidator(version?: SchemaVersion, options?: ValidateOptions): Validator;

package/dist/validate/regression.js

@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: 2026 The OATS Authors
+// SPDX-License-Identifier: Apache-2.0
+
+import v0 from "../compiled/0.8.0/regression.js";
+import { versionValidator } from "../validation.js";
+
+export { SchemaLookupError } from "../errors.js";
+export { ValidationError } from "../validation.js";
+
+const VERSIONS = new Map([["0.8.0", v0]]);
+
+export function getValidator(version, options) {
+  return versionValidator("regression", VERSIONS, version, options);
+}

package/dist/validate/temporal-segmentation.d.ts

@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: 2026 The OATS Authors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Validation of records against the `temporal-segmentation` OATS schema only, with precompiled validators.
+ *
+ * @module
+ */
+
+import type { SchemaVersion } from "../names.js";
+import type { ValidateOptions, Validator } from "../validation.js";
+
+export { SchemaLookupError } from "../errors.js";
+export { ValidationError, type ValidationErrorDetails, type ValidateOptions, type Validator } from "../validation.js";
+
+/**
+ * Return a cached {@link Validator} for the `temporal-segmentation` schema in schema version `version`, or in
+ * `SCHEMA_VERSION` if `version` is omitted.
+ *
+ * Formats (`date-time`, `uri`, …) are checked unless `options.checkFormats` is `false`.
+ *
+ * @param version An exact bundled version such as `"0.8.0"`.
+ * @param options Validation options.
+ * @throws {SchemaLookupError} `version` is not bundled, or does not contain `temporal-segmentation`.
+ * @throws {TypeError} `options` is not an object, has an unknown key, or `checkFormats` is not a boolean.
+ */
+export declare function getValidator(version?: SchemaVersion, options?: ValidateOptions): Validator;

package/dist/validate/temporal-segmentation.js

@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: 2026 The OATS Authors
+// SPDX-License-Identifier: Apache-2.0
+
+import v0 from "../compiled/0.8.0/temporal-segmentation.js";
+import { versionValidator } from "../validation.js";
+
+export { SchemaLookupError } from "../errors.js";
+export { ValidationError } from "../validation.js";
+
+const VERSIONS = new Map([["0.8.0", v0]]);
+
+export function getValidator(version, options) {
+  return versionValidator("temporal-segmentation", VERSIONS, version, options);
+}

package/dist/validate.d.ts

@@ -0,0 +1,40 @@
+import type { SchemaName, SchemaVersion } from "./names.ts";
+import { type ValidateOptions, type ValidationError, type Validator } from "./validation.ts";
+export { SchemaLookupError, UnknownSchemaError } from "./errors.ts";
+export { type ValidateOptions, ValidationError, type ValidationErrorDetails, type Validator } from "./validation.ts";
+/**
+ * Return a cached {@link Validator} for the schema `name` in schema version `version`, or in `SCHEMA_VERSION` if
+ * `version` is omitted.
+ *
+ * Formats (`date-time`, `uri`, …) are checked unless `options.checkFormats` is `false`.
+ *
+ * @param name The schema name, such as `"classification"`.
+ * @param version An exact bundled version such as `"0.8.0"`.
+ * @param options Validation options.
+ * @throws {UnknownSchemaError} `name` is not a schema in any bundled version.
+ * @throws {SchemaLookupError} `version` is not bundled, or does not contain `name`.
+ * @throws {TypeError} `options` is not an object, has an unknown key, or `checkFormats` is not a boolean.
+ */
+export declare function getValidator(name: SchemaName, version?: SchemaVersion, options?: ValidateOptions): Validator;
+/**
+ * Check `record` against the schema `name` in schema version `version`, or in `SCHEMA_VERSION` if `version` is
+ * omitted, and throw a {@link ValidationError} for the first error.
+ *
+ * Before OATS 1.0.0, a schema version may reject records that an older one accepted, so pass the version a record was
+ * written for. Arguments and other errors are as for {@link getValidator}; {@link iterErrors} returns every error.
+ *
+ * @throws {ValidationError} `record` does not conform.
+ */
+export declare function validate(record: unknown, name: SchemaName, version?: SchemaVersion, options?: ValidateOptions): void;
+/**
+ * Return whether `record` conforms to the schema `name` in schema version `version`.
+ *
+ * Arguments and errors are as for {@link validate}, except that a record that does not conform returns `false`.
+ */
+export declare function isValid(record: unknown, name: SchemaName, version?: SchemaVersion, options?: ValidateOptions): boolean;
+/**
+ * Return an iterator over every error in `record` against the schema `name` in schema version `version`.
+ *
+ * Arguments and errors are as for {@link validate}, except that each error is yielded rather than thrown.
+ */
+export declare function iterErrors(record: unknown, name: SchemaName, version?: SchemaVersion, options?: ValidateOptions): IterableIterator<ValidationError>;

package/dist/validate.js

@@ -0,0 +1,59 @@
+// SPDX-FileCopyrightText: 2026 The OATS Authors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Validation of records against the bundled OATS schemas, with precompiled validators.
+ *
+ * The validators generate no code at run time and have no dependencies, so they run under a strict Content Security
+ * Policy and in a browser without a bundler. This module includes every schema; to load only one, import
+ * `oatschema/validate/<name>` instead.
+ *
+ * @module
+ */
+import { COMPILED } from "./compiled/index.js";
+import { tableValidator } from "./validation.js";
+export { SchemaLookupError, UnknownSchemaError } from "./errors.js";
+export { ValidationError } from "./validation.js";
+/**
+ * Return a cached {@link Validator} for the schema `name` in schema version `version`, or in `SCHEMA_VERSION` if
+ * `version` is omitted.
+ *
+ * Formats (`date-time`, `uri`, …) are checked unless `options.checkFormats` is `false`.
+ *
+ * @param name The schema name, such as `"classification"`.
+ * @param version An exact bundled version such as `"0.8.0"`.
+ * @param options Validation options.
+ * @throws {UnknownSchemaError} `name` is not a schema in any bundled version.
+ * @throws {SchemaLookupError} `version` is not bundled, or does not contain `name`.
+ * @throws {TypeError} `options` is not an object, has an unknown key, or `checkFormats` is not a boolean.
+ */
+export function getValidator(name, version, options) {
+    return tableValidator(COMPILED, name, version, options);
+}
+/**
+ * Check `record` against the schema `name` in schema version `version`, or in `SCHEMA_VERSION` if `version` is
+ * omitted, and throw a {@link ValidationError} for the first error.
+ *
+ * Before OATS 1.0.0, a schema version may reject records that an older one accepted, so pass the version a record was
+ * written for. Arguments and other errors are as for {@link getValidator}; {@link iterErrors} returns every error.
+ *
+ * @throws {ValidationError} `record` does not conform.
+ */
+export function validate(record, name, version, options) {
+    tableValidator(COMPILED, name, version, options).validate(record);
+}
+/**
+ * Return whether `record` conforms to the schema `name` in schema version `version`.
+ *
+ * Arguments and errors are as for {@link validate}, except that a record that does not conform returns `false`.
+ */
+export function isValid(record, name, version, options) {
+    return tableValidator(COMPILED, name, version, options).isValid(record);
+}
+/**
+ * Return an iterator over every error in `record` against the schema `name` in schema version `version`.
+ *
+ * Arguments and errors are as for {@link validate}, except that each error is yielded rather than thrown.
+ */
+export function iterErrors(record, name, version, options) {
+    return tableValidator(COMPILED, name, version, options).iterErrors(record);
+}

package/dist/validation.d.ts

@@ -0,0 +1,74 @@
+import { type SchemaName, type SchemaVersion } from "./names.ts";
+/** Options for validation. */
+export interface ValidateOptions {
+    /** Whether to check formats (`date-time`, `uri`, …). Defaults to `true`. */
+    readonly checkFormats?: boolean;
+}
+/** The details of a {@link ValidationError}. */
+export interface ValidationErrorDetails {
+    /** The schema's name. */
+    readonly schemaName: SchemaName;
+    /** The exact schema version. */
+    readonly schemaVersion: SchemaVersion;
+    /** The location of the failing value within the record. */
+    readonly path?: readonly (string | number)[];
+    /** The location within the schema of the keyword that rejected it. */
+    readonly schemaPath?: readonly (string | number)[];
+    /** The JSON Schema keyword that rejected it, such as `"maxLength"` or `"required"`. */
+    readonly keyword?: string;
+}
+/**
+ * A record that does not conform to its schema.
+ *
+ * `path` locates the failing value within the record, `schemaPath` the schema location that rejected it,
+ * and `keyword` the JSON Schema keyword at the end of `schemaPath` (`"maxLength"`, `"required"`, …).
+ *
+ * `reason` shows each value from the record as `…`, quoting only property names, and is at most 1,000 characters.
+ * `message` adds the schema and the location, as in `classification 0.8.0 at /labels/0/score: … is greater than the
+ * maximum of 1`. Each string in `path` is at most 100 characters, and the location in `message` at most 1,000.
+ * The underlying validator's error is not kept.
+ */
+export declare class ValidationError extends Error {
+    /** Why the value was rejected, without the schema or the location. */
+    readonly reason: string;
+    /** The schema's name. */
+    readonly schemaName: SchemaName;
+    /** The exact schema version. */
+    readonly schemaVersion: SchemaVersion;
+    /** The location of the failing value within the record. Array indices are numbers. */
+    readonly path: readonly (string | number)[];
+    /** The location within the schema of the keyword that rejected the value. */
+    readonly schemaPath: readonly (string | number)[];
+    /** The JSON Schema keyword that rejected the value. */
+    readonly keyword: string;
+    constructor(reason: string, details: ValidationErrorDetails);
+}
+/**
+ * A validator for one schema version, from `getValidator`.
+ *
+ * Formats (`date-time`, `uri`, …) are checked unless {@link Validator.checkFormats} is `false`.
+ * Records are JSON values, such as the result of `JSON.parse`.
+ */
+export interface Validator {
+    /** The schema's name. */
+    readonly schemaName: SchemaName;
+    /** The exact schema version. */
+    readonly schemaVersion: SchemaVersion;
+    /** Whether formats (`date-time`, `uri`, …) are checked. */
+    readonly checkFormats: boolean;
+    /** Return whether `record` conforms. */
+    isValid(record: unknown): boolean;
+    /**
+     * Throw a {@link ValidationError} for the first error in `record`, if there is one.
+     *
+     * The first error is the first that {@link Validator.iterErrors} yields.
+     */
+    validate(record: unknown): void;
+    /**
+     * Return an iterator over every error in `record`, as {@link ValidationError}s.
+     *
+     * Every error is found before the first is yielded. The same record gives the same errors in the same order,
+     * but the order may change between releases.
+     */
+    iterErrors(record: unknown): IterableIterator<ValidationError>;
+}