API Reference

The built-in message catalogue, and what a translator must cover.

Creates, executes, composes, and inspects constraints.

Projects message keys and default English phrases from expectation values.

Constraint constructors usable without the Constraint.

Builds and traverses constraint descriptions.

Builds and renders portable constraint values.

The boxed-value projection behind tryCreate.

Reads and builds message identities.

Reads and builds catalogue-owned rendering metadata.

Builds renderers and renders messages through them.

Projects message keys and default English phrases from unsupported-operand reports.

Inspects, traverses, and renders violations.

Why one indivisible constraint failed.

What a size rule expects of a text length or collection count.

A reusable description of valid values, coupled to the closures that execute it.

One interpreted primitive: the complete semantic identity of a built-in constraint.

What a constraint says, as inspectable data.

The logical form of a constraint.

The closed set of operand and actual-value representations a constraint may carry across a description, diagnostic, or localization boundary.

The built-in text formats.

What a membership rule expects.

A message identity and the operands its template may interpolate.

A descriptor plus the rendering metadata its owning catalogue holds: the neutral fallback template and the optional plural operand.

Why a message format specification was rejected.

Why a relative message key could not be parsed.

One leaf of a projected message tree.

The ordinary resource lookup: an encoded resource key in, a translated template out.

One contextual level's request to an advanced resolver.

What an advanced resolver found for one contextual level.

Resolves one contextual level, or declines so Reified continues to a less specific one.

A violation projected for an external localization system, retaining its grouping.

What a numeric-property rule expects.

Why a constraint is invisible to export and proof.

An IEEE double retaining structural self-equality, including NaN and signed zero.

An IEEE single retaining structural self-equality, including NaN and signed zero.

What a presence rule expects of a value's shape.

What an ordering or equality rule expects.

The comparison a relation asserts between a value and an operand.

Renders localized messages for one document context and attribute.

A built-in operation that received an operand outside the portable value set.

A value to format, with the placeholder's format suffix when it carried one.

Why a value failed its constraint.

No description available.

Concise opt-in syntax for literals, immutable edits, cases, and matching.

No description available.

No description available.

Helpers for constructing, parsing, and rendering structured data paths.

A portable tree for structured data.

A named materialized structured-data case.

One focused difference between expected and actual structured data.

The reason an exact structural comparison differed.

One independent axis in a bounded Cartesian data matrix.

An opaque immutable edit applied by Data.tryPatch or Data.patch.

An opaque path-based expectation.

An opaque object-field instruction shared by data literals and object patterns.

Raised by matching when one or more expectations fail.

One failed selective or recursive data expectation.

Raised by Data.patch when an edit cannot be applied.

Describes why one immutable data edit could not be applied.

A path that addresses a location in structured data.

A segment in a structured data path.

An opaque recursive expectation used to match structured data.

A named immutable variation from one baseline value.

No description available.

Primitive parsers for untrusted serialized input.

Primitive parse failures returned by Parse helpers.

No description available.

The concise result vocabulary: the result { } computation expression, its accumulating result.list { } / result.array { } variants, and the lightweight admission functions (okIf, failIf, require, orError, mapError).

No description available.

# `Contract` A schema describes the current model.

Functions for defining explicit payload-less enum schema cases.

Functions for creating and inspecting external schema field names.

Functions for inspecting schema field metadata.

Functions for creating and inspecting schema field order metadata.

# `Inspect` `Inspect.model` turns a schema into finite metadata without parsing input or running application code.

# `JsonSchema` `JsonSchema.generate` publishes a schema as JSON Schema Draft 2020-12.

Ready-made schemas for the built-in refined values.

Functions for creating and rendering retained schema parse results.

# `Schema` The `Schema` module contains primitive schemas, collection and recursion combinators, union constructors, and the operations that parse or check a completed declaration.

Functions for running executable value checks against refined and primitive value schemas.

The concise schema-definition vocabulary: the record computation expression, its field and constructor forms, and the collection-schema operations.

Functions for lowering and rendering boundary schema failures.

Functions for inspecting and rendering accumulated schema failures.

Functions for creating and inspecting schema value format metadata.

The message keys Schema's own failures render through.

Functions for building and formatting schema error paths.

Marks the package that owns schema input, diagnostics, validation, and rules interpreters.

Functions for defining explicit tagged union schema cases.

Common complete representations for recommended authoring and serializer-compatible lifting.

A versioned wire contract whose successful result is the current domain model.

A progressively typed version chain.

A failure to select, parse, or migrate a versioned contract.

Describes one payload-less case for Schema.enumOf.

Describes one case in a bare-string enum value schema.

Describes a bare-string enum value schema.

Represents the source-facing name of a schema field.

Describes one typed field of a trusted model for schema interpreters.

Describes one field of a model schema for inspection interpreters.

Represents the zero-based position of a schema field in a model constructor and ordered interpreter output.

Builds an interpreter-specific typed record plan from a model schema's authored shape.

Holds an interpreter-specific typed record-plan fragment while compiling a schema.

A failure produced while migrating an older wire representation.

Describes a built model schema as an ordered list of field descriptions.

Identifies the intrinsic primitive shape of a schema value.

A schema parse result that retains its original structured input.

# `Schema<'model>` A `Schema<'model>` is a reusable declaration of a structured boundary.

Canonical value-schema resolution for a schema field.

Describes one value schema: its shape, declared format, and portable constraint metadata.

Schema input, checking, and contextual rule failures attached to diagnostics paths.

One or more accumulated schema failures.

Identifies the portable named format of a schema value, such as email.

One schema failure and its complete structural location.

Options that customize how structured data is parsed through a schema.

An immutable location within structured schema input.

Describes the shape of a value schema as inspectable metadata for non-validation interpreters.

Whether boundary input for a field must be supplied.

Describes one tagged union case for Schema.union and its compatibility variants.

Describes one case in a union value schema.

Describes the semantic payload shape of one union case.

Describes a tagged union value schema.

Controls how a case's authored fields are represented inside adjacent or external tagging.

A complete, inspectable union wire representation.

The explicit source of a contract version.

Declares one field inside schema<'model> { }, and configures it when followed by a block.

No description available.

# `Schema` The `Schema` module contains primitive schemas, collection and recursion combinators, union constructors, and the operations that parse or check a completed declaration.

# `Schema` The `Schema` module contains primitive schemas, collection and recursion combinators, union constructors, and the operations that parse or check a completed declaration.

# `Schema` The `Schema` module contains primitive schemas, collection and recursion combinators, union constructors, and the operations that parse or check a completed declaration.