Accept one or more matching branches and decode with the first matching branch in list order. Empty unions fail construction.

Accept any admitted JSON and return the original opaque Json unchanged. No schema constraints or conversions are applied. Admission still excludes nonfinite numbers and non-scalar strings/keys; this is not arbitrary runtime data. The schema is unconstrained within the documented admitted JSON domain.

Accept homogeneous arrays and decode every element in input order.

Assert a supported format on string inputs, preserving the base converter. UUID accepts the 36-character, case-insensitive hexadecimal/dash syntax, including nil UUIDs, without a URN prefix or whitespace. Version/variant bits are not restricted. Nonstrings remain governed by the base definition.

Accept JSON booleans.

Accept exactly this boolean.

Bind a handler to its authoritative contract. Construction runs no callbacks.

Return the receiving contract without exposing its handler.

Return the receiving contract’s structural definition for schema generation.

Intersect inclusive integer bounds, Unicode code-point string lengths, homogeneous array lengths or dictionary key counts. None leaves a side unbounded. Unsupported definitions and invalid intervals fail construction.

Require between minimum and maximum structurally matching array items. Preserve the original decoder; matching-definition converters never run.

Wrap a completed definition without adding semantic requirements.

Return the structural definition. Its schema does not describe arbitrary semantic requirements and is not sufficient to establish contract acceptance.

Return every requirement description in declaration order, without callbacks.

Validate the entire input before running typed conversion. Invalid inputs run no converters; exceptions from trusted callbacks propagate.

Decode once, then run each semantic requirement once in declaration order. Structural rejection skips all checks. Semantic failures are collected; exceptions propagate and may prevent later checks from running.

Attach a JSON Schema default annotation without inserting values during decoding or checking this sample against the definition. defaulted is the separate record-field operation for validated defaults applied on absence. A defaulted field’s declared default takes precedence over child annotations.

Add a field with an admitted JSON default validated during construction. When absent, decode the default with the child converter. A present invalid value still fails; defaults do not mutate the input or bypass validation.

When trigger is present in the original object, require every listed key. Null counts as present; decoded defaults do not create input presence. Repeated rules for the same trigger merge their keys. Duplicate keys are normalized, and empty lists and self-dependencies are allowed.

Add a schema description without changing validation or decoding.

Accept objects whose values satisfy the child definition. Decode to a Gleam list of key/value pairs, preserving original keys rather than a JS object.

Append one required position, consuming one constructor argument.

Attach the JSON Schema examples annotation without affecting acceptance or conversion. Examples are admitted JSON, but need not satisfy the definition. A later call replaces an earlier examples annotation at the same schema node.

Reject input accepted by a forbidden structural definition. Preserve the base output; forbidden-definition converters never run.

Finish a typed record with the chosen undeclared-key policy.

Close a tuple. Short arrays and extra positions are rejected.

Attach a JSON Schema format annotation, such as “email” or “uuid”. This does not check the format, change acceptance or invoke converters. Custom names are allowed. Names must contain only Unicode scalar values.

Decode and check the stored contract once, then invoke the handler once. Rejection invokes no handler. Callback exceptions propagate operationally. A Result response remains nested; output is not checked.

Verify the stored contract once, then invoke the handler once. Semantic requirements cause one decoding pass; without them no converter runs. Admission and application policy are separate. Certificates from other contracts cannot bypass this check. Exceptions propagate operationally.

Validate the consequence only when the structural condition accepts input. Retain the base output; condition/consequence converters never run.

Validate exactly the selected structural branch, retaining the base decoder.

Accept exactly this safe integer; reject constants outside the safe range.

Require safe-integer inputs divisible by a positive safe-integer divisor. This exact integer policy does not accept fractional divisors or number() definitions. Apply before naming. Repeated constraints intersect.

Construct a JSON array from already admitted children, preserving list order. Child values are not serialized, parsed or recursively rechecked.

Construct a JSON Boolean.

Bind a JSON receiving handler to its authoritative contract.

Return the receiving contract without exposing its handler.

Return the receiving contract’s structural definition for schema generation.

Construct a JSON number from an Int in the common safe-integer range. Reject larger integers rather than silently rounding them to binary64.

Construct JSON null.

Construct a finite binary64 JSON number, preserving its numeric value.

Construct a JSON object from already admitted children. Keys must contain Unicode scalars and be unique. Declaration order is retained; serialization uses the usual canonical key ordering. Keys such as proto are ordinary keys. The first invalid or repeated key identifies the rejected declaration.

Construct a JSON string containing only Unicode scalar values.

Compose a completed definition inside a recursive builder. Its converter ignores the builder environment and retains its own recursion.

Transform decoded output without changing schema acceptance. The callback runs only during successful decoding and must return the declared output type.

Name a definition for local $defs/$ref reuse. Names must start with an ASCII letter and contain only ASCII letters, digits, underscores or hyphens. Conflicting names fail when the composed graph is validated or emitted.

Accept JSON null and decode it to Nil.

Accept exactly null.

Accept null as None, or decode the child as Some. This does not make a record field optional.

Decode any admitted finite IEEE-754 number to Float, including integers. JSON parsing may round or underflow; decoding preserves the parsed value.

Intersect a number definition’s interval with finite inclusive/exclusive bounds. Reject inverted intervals and exclusive equal endpoints.

Accept exactly one structurally matching branch and decode with it. Overlapping matches are rejected. Empty unions fail construction.

Add an optional field, consuming an Option(a) constructor argument. Absence is None; present values must satisfy the child, including null.

Admit JSON text without invoking a definition or converter. Duplicate object keys use the parser’s last value; numeric values use IEEE-754 binary64. String values and object keys must contain only Unicode scalar values.

Intersect an unanchored ECMAScript Unicode regular expression with a string definition. Anchor explicitly for whole-string matching. Invalid expressions and unsupported underlying definitions fail construction.

Constrain every own object key without changing decoded values or keys. The key definition is used for validation only; its converter never runs.

Start a record with a curried constructor. Each field consumes one argument; call finish after supplying all fields. Multi-argument constructors need currying.

Build a guarded self-recursive definition, running the builder once. The supplied plan can compose inside the builder but cannot be decoded, validated or emitted independently, including after construction completes.

Build two guarded recursive definitions with independent output types. Both builder plans share a typed pair environment; return both bodies once.

Add a requirement without running it. Checks inspect decoded values, so projected extra fields and distinctions removed by maps are unavailable. Description strings must contain Unicode scalar values.

Add a required field. Duplicate field names fail construction.

Accept integral numbers between -9007199254740991 and 9007199254740991.

Return a JSON Schema 2020-12 document as Gargamelle’s opaque Json, not gleam/json.Json. Unfinished or conflicting reference graphs fail operationally.

Return a JSON Schema 2020-12 string in the chosen layout, including local references.

Accept exactly this string.

Accept one of the supplied strings. Empty or duplicate alternatives fail construction.

Construct a discriminated union of record variants. Empty lists, duplicate tags and fields redeclaring the discriminator are construction errors.

Accept JSON strings.

Add a schema title without changing validation or decoding.

Convert already admitted JSON to the standard gleam/json representation. This is a one-way representation conversion, not validation or certification. Standard JSON serialization rules apply, including normalization of zero signs.

Serialize any admitted JSON value in the chosen layout. Negative zero becomes 0. Compact is canonical; Pretty changes only whitespace.

Start an exact-length positional array with a curried typed constructor.

Require structurally distinct JSON items in a direct homogeneous array definition. Uniqueness is checked before mapping, not on decoded outputs.

Validate an admitted value without invoking constructors or map callbacks. Unfinished/conflicting reference graphs and resource exhaustion are operational failures rather than data errors.

Check contract acceptance. A contract without semantic requirements validates without conversion; otherwise decoding occurs once to supply the checks.

Finish a tagged record branch. Do not declare the discriminator as a field.

Describe a tagged branch without changing its acceptance contract.

Transform a tagged branch’s decoded output without changing its schema.

Return the exact contract, including checks and captured context, that accepted the stored JSON. The output type parameter alone does not identify guarantees.

Return the checked contract’s underlying structural definition.

Return original admitted JSON without validation, decoding or serialization.

Verify a full contract and retain original JSON and that exact contract. No decoded value is retained. Semantic checks require decoding once; contracts without them validate without conversion.