Builds a schema for an array.

A schema for `bool`.

Closes a fully-applied pipeline and returns the schema for `'T`.

A schema for `byte`.

A schema for `char` backed by a single-character string.

Builds a schema for `ICollection<'T>`. This preserves the normal array wire shape while interoperating with common mutable collection interfaces from .NET APIs.

Captures the constructor used to rebuild `'T` during decoding.

Creates a schema from a raw structural definition. This is public for advanced integrations, but most callers should prefer the higher-level helpers in this module.

A schema for `DateTime` using the round-trippable `"O"` string format.

A schema for `DateTimeOffset` using the round-trippable `"O"` string format.

A schema for `decimal`.

Pipeline DSL helpers. The pipeline starts by capturing the curried constructor up front so subsequent field steps only describe the wire layout. We still ask for `'T` explicitly because relying on field-label inference alone becomes brittle as soon as multiple record types share names like `Id` or `Name`. Starts a pipeline schema definition for `'T`.

Defers schema construction so authored contracts can be recursive.

Some config shapes use an explicit empty collection as "use the default collection" rather than as a meaningful distinct value.

Empty strings are often used as a legacy stand-in for "not provided". This wrapper keeps that conversion opt-in rather than weakening string option semantics globally.

Builds a message envelope using `type` and `data` as the default field names.

Builds a message envelope with custom discriminator and payload field names.

Adds a field that can be resolved automatically from its type.

Adds a field with an explicit nested schema. Use this when the field type needs a custom schema or should not rely on automatic resolution.

A schema for `float`.

Keep the .NET path using round-trip float formatting, but let Fable use the host number string form instead of rejecting the `"R"` specifier.

A schema for `Guid` using the round-trippable `"D"` string format. Common domain identity and timestamp types ride on top of the string codec so JSON and XML stay symmetric without extra parser branches.

Builds an inline message envelope using `type` as the default discriminator field name.

Builds an inline message envelope with a custom discriminator field name.

Builds an explicit tagged-union schema that inlines payload fields next to the discriminator.

Builds an explicit tagged-union schema with a custom inline discriminator field name.

A schema for `int`.

A schema for `int16`.

A schema for `int64`.

Builds a schema for arbitrary JSON values. This is the explicit fallback for imported contracts that cannot be represented as a deterministic record/array/primitive schema without a separate normalization or validation step.

Builds a schema for an F# list.

Projects an existing schema through total wrap and unwrap functions. Use this when the wire shape is unchanged but the in-memory model uses a wrapper type.

Creates a message tag with no payload for envelope-style contracts.

Creates a message tag with a payload for envelope-style contracts.

Config-style payloads sometimes treat absent fields as "no value" instead of as a contract violation. Keep that policy explicit.

Config-style payloads sometimes have explicit defaults that should be applied only when a field is absent, not when it is present-but-invalid.

Some wire contracts require at least one item, but keeping that rule in the schema is still clearer than scattering ad hoc list checks elsewhere.

Empty strings are often accidental placeholders rather than meaningful values. This helper keeps that validation explicit and reusable.

Config-style payloads sometimes use explicit `null` as "use the default value" for non-option fields. Keep that policy local.

Builds a schema for an option value. The default semantics are strict: `None` is explicit on the wire, and missing fields still fail unless you add a field-policy wrapper.

Positive identifiers and counters are a common wire-level constraint, and `tryMap` keeps that rule opt-in rather than global.

Builds a schema for `IReadOnlyList<'T>`. Keep the wire form identical to arrays while still allowing .NET-facing APIs to expose read-only collection interfaces.

Builds a schema for `ResizeArray<'T>` / `List`. .NET interop often surfaces mutable list shapes even when the wire contract is just a homogeneous JSON or XML array.

Resolves a built-in schema for a CLR type. This powers automatic field resolution for primitives, F# collections, selected .NET collection interfaces, options, and the common built-in wrapper types.

A schema for `sbyte`.

A schema for `string`.

Builds a finite string-valued contract for a small set of named cases. This keeps the wire shape explicit as strings while still compiling to strongly typed values and exporting a JSON Schema `enum`.

Builds a finite string-valued contract while keeping a domain-level name available at the call site for readability.

Creates a tag with no payload.

Creates a tag with a payload value.

A schema for `TimeSpan` using the invariant `"c"` format.

Some contracts normalize surrounding whitespace at the boundary rather than making every caller remember to trim before encode and after decode.

Smart constructors need a way to reject decoded values without forcing callers to smuggle exceptions through plain `map`.

A schema for `uint16`.

A schema for `uint32`.

A schema for `uint64`.

Builds an explicit tagged-union schema using default wire field names.

Builds an explicit tagged-union schema with custom wire field names.

Exposes the erased schema view for advanced integrations.