@thomasfosterau/effect-forms 0.0.0

package/dist/index.d.ts

@@ -0,0 +1,878 @@
+import * as Schema from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+import * as Effect from "effect/Effect";
+import * as SchemaIssue from "effect/SchemaIssue";
+import * as Duration from "effect/Duration";
+declare namespace Coerce_d_exports {
+  export { booleanFromCheckbox, emptyToNull, emptyToUndefined, numberFromField, trimToNull, trimToUndefined };
+}
+/**
+ * @copyright Thomas Foster
+ *
+ * Tri-state coercers for the HTML-form boundary.
+ *
+ * An HTML form submits every value as a string, and an absent optional field
+ * arrives as `undefined` (or an empty string). Mapping that onto a
+ * value / `null` / `undefined` update contract — where a value **sets**, `null`
+ * **clears** a nullable field, and `undefined` **skips** (carry-forward) — is
+ * the same boundary discipline the host app applies, lifted here so any
+ * consumer of the core gets it without a framework dependency.
+ *
+ * These are plain, total functions: they never throw and never reach for a
+ * framework's `error()` helper (validation failures belong on the schema, not
+ * in a coercer).
+ *
+ * @module effect-forms/Coerce
+ */
+/** Empty string / `undefined` → `undefined`; otherwise the value (skip semantics). */
+declare function emptyToUndefined<T>(value: T | "" | undefined): T | undefined;
+/**
+ * `undefined` stays `undefined` (skip); empty string / `null` → `null`
+ * (clear a nullable field); otherwise the value (set). The three-state coercer
+ * for nullable update fields.
+ */
+declare function emptyToNull<T>(value: T | "" | null | undefined): T | null | undefined;
+/** Trim, then {@link emptyToUndefined}: whitespace-only collapses to `undefined` (skip). */
+declare function trimToUndefined(value: string | undefined): string | undefined;
+/** Trim, then {@link emptyToNull}: whitespace-only / blank clears (`null`). */
+declare function trimToNull(value: string | undefined): string | null | undefined;
+/**
+ * Map a numeric text field onto the value / `null` / `undefined` contract.
+ * Blank clears on the nullable path and skips otherwise; a present value
+ * parses with `Number` (`NaN` for non-numeric input — validate downstream).
+ */
+declare function numberFromField(raw: string | undefined, options: {
+  nullable: false;
+}): number | undefined;
+declare function numberFromField(raw: string | undefined, options: {
+  nullable: true;
+}): number | null | undefined;
+/**
+ * Interpret a checkbox field. An HTML checkbox submits its `value` (default
+ * `"on"`) only when checked and omits the field entirely when unchecked, so a
+ * present field is `true` and an absent one is `false`. The truthy strings
+ * `"on"` / `"true"` / `"1"` / `"yes"` all read as `true`; an explicit
+ * `"false"` / `"0"` / `"off"` / `"no"` reads as `false`.
+ */
+declare function booleanFromCheckbox(raw: string | undefined): boolean;
+declare namespace Command_d_exports {
+  export { AdaptOverrides, CommandPlan, FieldKind, FieldPlan, FormInputRecord, blankDefaults, createAdapter, formInputFields, jsonRowsFromField, plan, updateAdapter };
+}
+/** How a command field renders and coerces at the form boundary. */
+type FieldKind = "text" | "id" | "number" | "date" | "jsonArray" | "boolean" | "enum" | "structured";
+/** One command field's derived plan, as plain data. */
+interface FieldPlan {
+  readonly key: string;
+  readonly kind: FieldKind;
+  /** Present on the create struct. */
+  readonly inCreate: boolean;
+  /** Bare (non-optional) on the create struct. */
+  readonly createRequired: boolean;
+  /** Present on the update struct. */
+  readonly inUpdate: boolean;
+  /** `optional(NullOr(...))` on the update struct — blank clears (`null`). */
+  readonly updateClearable: boolean;
+  /**
+   * The field's literal option values, read off the AST — present only when
+   * `kind` is `"enum"`. In declaration order, stringified (a `<select>`'s
+   * option values are always strings at the form boundary, whatever the
+   * decoded literal's own type).
+   */
+  readonly options?: readonly string[];
+}
+/** The derived plan for one entity's create/update command pair. */
+interface CommandPlan {
+  /** Every field except `id`, in update-struct declaration order (create-only fields appended). */
+  readonly fields: readonly FieldPlan[];
+  /** The create struct carries an optional client-generated `id` (idempotent retries). */
+  readonly clientId: boolean;
+}
+/** Per-field adapter overrides — the escape hatch for genuinely irregular coercion. */
+type AdaptOverrides = Readonly<Record<string, (raw: string | undefined) => unknown>>;
+/** A validated all-string multipart input, as the Form-Input schemas produce it. */
+type FormInputRecord = Readonly<Record<string, string | undefined>>;
+/** Minimal runtime shape of a command `Schema.Struct`. */
+interface StructLike {
+  readonly fields: Record<string, Schema.Top>;
+}
+/**
+ * Read a create/update command struct pair into a {@link CommandPlan}.
+ * Runs once at module load — probe cost is a handful of tiny decodes per
+ * field, never per render or per request.
+ */
+declare const plan: (create: StructLike, update: StructLike) => CommandPlan;
+/**
+ * Derive the all-string Form-Input schema fields for one mode — every value is
+ * a string at the multipart boundary. Create-required fields get a min-length
+ * check so blankness surfaces as an inline field error; the update `id` gets
+ * the UUID check. Spread into `Schema.Struct({ ...Command.formInputFields(plan,
+ * "create") })`, with `overrides` spread last for irregular fields.
+ */
+declare const formInputFields: (commandPlan: CommandPlan, mode: "create" | "update", overrides?: Readonly<Record<string, Schema.Top>>) => Record<string, Schema.Top>;
+/**
+ * Blank string defaults for one mode's Form-Input shape. Client-id entities
+ * override `id` at the call site (`{ ...blankDefaults(plan, "create"), id:
+ * crypto.randomUUID() }`) so retries stay idempotent.
+ */
+declare const blankDefaults: (commandPlan: CommandPlan, mode: "create" | "update") => Record<string, string>;
+/**
+ * Parse a JSON-encoded row list (a contributor list) from a multipart form
+ * field. A blank or absent field yields `undefined` (skip — leave the existing
+ * list untouched); an empty JSON array (`"[]"`) clears the list. Rows keep
+ * `id` / `creditedName` when present; `orderingPosition` falls back to the
+ * row's array index. Throws a plain `Error` on a malformed payload — mapping
+ * that onto a framework response is the caller's concern.
+ */
+declare const jsonRowsFromField: (raw: string | undefined, label: string) => {
+  id?: string | undefined;
+  agentId: string;
+  creditedName?: string | undefined;
+  orderingPosition: number;
+}[] | undefined;
+/**
+ * Derive the create adapter: validated all-string input → encoded create
+ * command payload. `overrides` replace the default per-field coercion for
+ * genuinely irregular fields (e.g. a create-time fallback default).
+ */
+declare const createAdapter: (commandPlan: CommandPlan, overrides?: AdaptOverrides) => (input: FormInputRecord) => Record<string, unknown>;
+/**
+ * Derive the update adapter: validated all-string input → encoded update
+ * command payload (value sets, `null` clears a clearable field, `undefined`
+ * skips). The required `id` passes through as-is — the command's canonical
+ * decode brands it.
+ */
+declare const updateAdapter: (commandPlan: CommandPlan, overrides?: AdaptOverrides) => (input: FormInputRecord) => Record<string, unknown>;
+declare namespace Issues_d_exports {
+  export { FormIssue, FormPath, LeafFormatter, defaultLeafFormatter, filterOutputToFormIssues, schemaIssuesToFormIssues };
+}
+/**
+ * A path into the form's data. String segments address object keys; number
+ * segments address array indices. The empty path addresses the form root
+ * (a whole-form / cross-field message).
+ */
+type FormPath = ReadonlyArray<string | number>;
+/** One validation failure: where it happened ({@link FormPath}) and why. */
+interface FormIssue {
+  readonly path: FormPath;
+  readonly message: string;
+}
+/**
+ * Render one terminal issue leaf into a human-readable message. The default
+ * defers to the issue's own `toString`, which Effect Schema renders into a
+ * readable sentence (e.g. `Expected string, got 1`). Override it to localise
+ * or to map specific leaf `_tag`s to custom copy.
+ */
+type LeafFormatter = (issue: SchemaIssue.Issue) => string;
+/** The default leaf formatter — Effect Schema's own rendering of the leaf. */
+declare const defaultLeafFormatter: LeafFormatter;
+/**
+ * Walk an Effect Schema issue tree, emitting one {@link FormIssue} per leaf
+ * failure. Path segments accumulate through `Pointer` nodes; `Composite` and
+ * `AnyOf` fan out to siblings; `Filter` / `Encoding` are transparent
+ * wrappers. An `AnyOf` with no recorded member failures (a bare union
+ * mismatch) is itself a leaf.
+ */
+declare function schemaIssuesToFormIssues(issue: SchemaIssue.Issue, format?: LeafFormatter): FormIssue[];
+/**
+ * Normalise a filter predicate's {@link Schema.FilterOutput} into a flat list of
+ * {@link FormIssue}s (empty on success). Shared by whole-form refinements
+ * ({@link module:effect-forms/FormBuilder}) and per-field validators
+ * ({@link module:effect-forms/Validate}) so both fold into the same nested
+ * error tree as schema-decode failures.
+ */
+declare function filterOutputToFormIssues(output: Schema.FilterOutput): FormIssue[];
+declare namespace Constraints_d_exports {
+  export { InputConstraint, InputConstraints, constraintAt, constraintsFromSchema, isLeafConstraint };
+}
+/** Native validation attributes for a single input. */
+interface InputConstraint {
+  readonly required?: boolean;
+  readonly min?: number | string;
+  readonly max?: number | string;
+  readonly minlength?: number;
+  readonly maxlength?: number;
+  readonly pattern?: string;
+  readonly step?: number;
+}
+/** A nested tree of {@link InputConstraint}s mirroring the schema's shape. */
+interface InputConstraints {
+  readonly [key: string]: InputConstraint | InputConstraints | undefined;
+}
+/** Whether a node in an {@link InputConstraints} tree is a leaf ({@link InputConstraint}) rather than a branch. */
+declare const isLeafConstraint: (value: InputConstraint | InputConstraints) => value is InputConstraint;
+/**
+ * Derive the {@link InputConstraints} for a struct schema. Non-struct schemas
+ * yield an empty tree. `overrides` (deep-merged over the derived tree, and
+ * winning on conflict) is the seam for anything the AST walk does not infer.
+ */
+declare function constraintsFromSchema(schema: Schema.Top, overrides?: InputConstraints): InputConstraints;
+/**
+ * Read the {@link InputConstraint} leaf at `path` in an {@link InputConstraints}
+ * tree, defaulting to `{}` when `path` has no derived constraints. Array
+ * indices in `path` are skipped rather than descended into — the tree has no
+ * per-item nodes to index into, since {@link constraintsForType} derives one
+ * constraint (or branch) per *field*, shared by every item at that field. A
+ * bare item path (`tags[0]`) resolves to that shared leaf; a path that
+ * continues past the index into a struct item's own field (`items[0].label`)
+ * skips the index and resolves straight to `label`'s derived constraint.
+ */
+declare function constraintAt(constraints: InputConstraints, path: FormPath): InputConstraint;
+declare namespace Path_d_exports {
+  export { FieldPath, IndexMap, PathValue, clearAll, fromString, getAt, insertAt, isUnder, moveAt, remapIndex, remapKeyedRecord, removeAt, replaceAt$1 as replaceAt, setAt, swapAt, toString };
+}
+/**
+ * Read the value at `path`. Returns `undefined` if any segment is missing or
+ * traverses a non-object. The empty path returns the object itself.
+ */
+declare function getAt(obj: unknown, path: FormPath): unknown;
+/**
+ * Return a new tree with the value at `path` replaced by `value`. Objects and
+ * arrays along the path are cloned (structural sharing elsewhere); missing
+ * containers are created as arrays for numeric segments and objects otherwise.
+ * The empty path returns `value`. Pure — `obj` is never mutated.
+ */
+declare function setAt<T>(obj: T, path: FormPath, value: unknown): T;
+/** Whether `path` is `root` or nested beneath it. */
+declare function isUnder(path: FormPath, root: FormPath): boolean;
+/**
+ * Render a {@link FormPath} as flat field-name notation: string segments join
+ * with `.` and number segments become `[n]` (`["tags", 0]` → `"tags[0]"`).
+ * The inverse of {@link fromString}.
+ */
+declare function toString(path: FormPath): string;
+/**
+ * Parse flat field-name notation into a {@link FormPath}: integer tokens become
+ * number segments (array indices), everything else stays a string. The inverse
+ * of {@link toString}.
+ */
+declare function fromString(name: string): FormPath;
+/**
+ * The deep-key type: every valid {@link toString} path into `T`, as a union of
+ * string literals (`"author.name"`, `"tags[0]"`, `"tags[0].label"`, …). This is
+ * the type-checked counterpart of a hand-written {@link FormPath} — a typo'd
+ * segment or a path into a field that doesn't exist is a compile error. Bounded
+ * to a fixed recursion depth ({@link Prev}'s length) so a struct with cycles
+ * (there shouldn't be any — form data is JSON-shaped) can't blow up inference.
+ *
+ * Used by {@link module:effect-forms-svelte/FormStore}'s `field(path)` — see
+ * the trade-off recorded in `docs/decisions/` for why this was chosen over the
+ * core's (now-removed) opaque `FieldRef`.
+ */
+type FieldPath<T, D extends number = 8> = T extends object ? [D] extends [never] ? never : { [K in Extract<keyof T, string>]: `${K}${PathSuffix<T[K], Prev[D]>}`; }[Extract<keyof T, string>] : never;
+/** Recursion-depth countdown used by {@link FieldPath} / {@link PathValue}. */
+type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7];
+/**
+ * The continuation after a key: nothing, an array index (the bracket closes
+ * immediately — `[0]`, not `[0.label]` — then {@link PathSuffix} recurses on
+ * the element type for whatever comes after), or `.key`.
+ */
+type PathSuffix<T, D extends number> = [D] extends [never] ? "" : T extends ReadonlyArray<infer E> ? "" | `[${number}]${PathSuffix<E, Prev[D]>}` : T extends object ? "" | { [K in Extract<keyof T, string>]: `.${K}${PathSuffix<T[K], Prev[D]>}`; }[Extract<keyof T, string>] : "";
+/** The base key of a single dot-segment (`"tags[0]"` → `"tags"`). */
+type SegmentBase<S extends string> = S extends `${infer Base}[${string}` ? Base : S;
+/** The bracket indices of a single dot-segment (`"tags[0][1]"` → `["0", "1"]`), untyped past presence. */
+type SegmentIndices<S extends string> = S extends `${string}[${infer Idx}]${infer Rest}` ? [Idx, ...SegmentIndicesRest<Rest>] : [];
+/** Continuation of {@link SegmentIndices} once the leading (non-bracket) prefix has been consumed. */
+type SegmentIndicesRest<S extends string> = S extends `[${infer Idx}]${infer Rest}` ? [Idx, ...SegmentIndicesRest<Rest>] : [];
+/** Step through an array type once per entry in `Idxs`. */
+type ApplyIndices<T, Idxs extends readonly unknown[]> = Idxs extends [unknown, ...infer Rest] ? T extends ReadonlyArray<infer E> ? ApplyIndices<E, Rest> : never : T;
+/** Resolve a single dot-segment (base key plus any bracket indices) against `T`. */
+type ResolveSegment<T, S extends string> = SegmentBase<S> extends keyof T ? ApplyIndices<T[SegmentBase<S>], SegmentIndices<S>> : never;
+/**
+ * The value type at a {@link FieldPath} `P` into `T` — the leaf type `field(path)`
+ * resolves to. `PathValue<{ tags: string[] }, "tags[0]">` is `string`.
+ */
+type PathValue<T, P extends string> = P extends `${infer Head}.${infer Rest}` ? PathValue<ResolveSegment<T, Head>, Rest> : ResolveSegment<T, P>;
+/**
+ * Maps an array index that existed before an index-shifting mutation to where
+ * it lives afterwards, or to `null` when the item at that index no longer
+ * exists (its per-index state should be dropped). Built by {@link removeAt} /
+ * {@link insertAt} / {@link swapAt} / {@link moveAt} / {@link replaceAt}, and
+ * consumed by {@link remapIndex} / {@link remapKeyedRecord} and
+ * `Errors.remapIndices` to keep per-index state (touched flags, error trees)
+ * in sync with the row it was recorded against.
+ */
+type IndexMap = (index: number) => number | null;
+/** The {@link IndexMap} for removing the item at `index`: shifts later indices down by one. */
+declare function removeAt(index: number): IndexMap;
+/** The {@link IndexMap} for inserting an item at `index`: shifts `index` and later up by one. */
+declare function insertAt(index: number): IndexMap;
+/** The {@link IndexMap} for swapping the items at `a` and `b`. */
+declare function swapAt(a: number, b: number): IndexMap;
+/** The {@link IndexMap} for moving the item at `from` to `to`, shifting the items between. */
+declare function moveAt(from: number, to: number): IndexMap;
+/** The {@link IndexMap} for replacing the item at `index` in place: drops only that index's state. */
+declare function replaceAt$1(index: number): IndexMap;
+/** The {@link IndexMap} for clearing every item in the array: drops all per-index state. */
+declare const clearAll: IndexMap;
+/**
+ * Remap `path`'s index segment immediately under `arrayPath` through `map`.
+ * Paths outside `arrayPath`, and `arrayPath` itself (a whole-array message),
+ * pass through unchanged; a path whose index segment maps to `null` is
+ * dropped (returns `null`) — its item no longer exists. Pure.
+ */
+declare function remapIndex(path: FormPath, arrayPath: FormPath, map: IndexMap): FormPath | null;
+/**
+ * Remap every entry of a flat, path-keyed record (a {@link toString} key per
+ * entry — e.g. touched flags) through {@link remapIndex}. Entries whose path
+ * maps to `null` are dropped. Pure.
+ */
+declare function remapKeyedRecord<T>(record: Record<string, T>, arrayPath: FormPath, map: IndexMap): Record<string, T>;
+declare namespace Errors_d_exports {
+  export { ErrorSource, FormErrors, ROOT_ERROR_KEY, SourcedErrors, TypedFormErrors, clearSourceAt, emptySourced, flattenErrors, getError, hasErrors, issuesToErrors, mergeErrors, mergeSourced, noErrors, remapIndices, replaceAt, setError, setSourceAt };
+}
+/** The root key under which a branch's own (non-field) messages are stored. */
+declare const ROOT_ERROR_KEY = "_errors";
+/**
+ * A nested tree of validation messages. Leaves are `string[]`; branches are
+ * nested {@link FormErrors}; a branch's own messages live under
+ * {@link ROOT_ERROR_KEY}. Always JSON-serialisable.
+ */
+interface FormErrors {
+  readonly [ROOT_ERROR_KEY]?: readonly string[];
+  readonly [key: string]: FormErrors | readonly string[] | undefined;
+}
+/**
+ * A {@link FormErrors} tree typed to the shape of `A`, so fields are accessed
+ * by name with type-safety: for `A = { name: string; author: { bio: string } }`,
+ * `errors.name` is `readonly string[] | undefined` and `errors.author?.bio`
+ * likewise. A branch's own (cross-field) messages live under `_errors`. The
+ * runtime value is an ordinary {@link FormErrors} — this only refines the type.
+ */
+type TypedFormErrors<A> = [NonNullable<A>] extends [ReadonlyArray<infer E>] ? {
+  readonly [index: number]: TypedFormErrors<E> | undefined;
+  readonly _errors?: readonly string[];
+} : [NonNullable<A>] extends [object] ? { readonly [K in keyof A]?: TypedFormErrors<A[K]>; } & {
+  readonly _errors?: readonly string[];
+} : readonly string[];
+/** Build a nested {@link FormErrors} tree from a flat list of {@link FormIssue}s. */
+declare function issuesToErrors(issues: ReadonlyArray<FormIssue>): FormErrors;
+/**
+ * Flatten a {@link FormErrors} tree back into a list of {@link FormIssue}s, in
+ * depth-first order. The inverse of {@link issuesToErrors} (modulo message
+ * ordering within a single field).
+ */
+declare function flattenErrors(errors: FormErrors): FormIssue[];
+/** Whether the tree carries any message anywhere. */
+declare function hasErrors(errors: FormErrors): boolean;
+/**
+ * Read the messages attached directly to `path` (a leaf's list, or a branch's
+ * own {@link ROOT_ERROR_KEY}). Returns `undefined` when the path has no direct
+ * messages.
+ */
+declare function getError(errors: FormErrors, path: FormPath): readonly string[] | undefined;
+/** Return a new tree with `message` added at `path`. Pure. */
+declare function setError(errors: FormErrors, path: FormPath, message: string): FormErrors;
+/** Combine two error trees into one (left then right). Pure. */
+declare function mergeErrors(a: FormErrors, b: FormErrors): FormErrors;
+/** The empty error tree. */
+declare const noErrors: FormErrors;
+/**
+ * Remap the array-index segments of every message under `arrayPath` through
+ * `map` (see {@link module:effect-forms/Path.IndexMap}), so an error recorded
+ * against a row follows that row through a remove / insert / swap / move.
+ * Messages whose index maps to `null` are dropped. Pure.
+ */
+declare function remapIndices(errors: FormErrors, arrayPath: FormPath, map: IndexMap): FormErrors;
+/**
+ * Return a new tree with the messages *directly at* `path` replaced by
+ * `messages` (removing the key when `messages` is empty), leaving every other
+ * path — including children of a branch `path` — untouched. Unlike
+ * {@link setError} (which appends one message), this is the "this field's
+ * validator just ran, here is its complete result" operation a per-field
+ * validator needs: it can clear a field back to valid without disturbing
+ * sibling or nested messages. Pure.
+ */
+declare function replaceAt(errors: FormErrors, path: FormPath, messages: readonly string[]): FormErrors;
+/**
+ * Where a message in a {@link FormErrors} tree came from. `"server"` messages
+ * come from the last submission response; `"client"` messages come from
+ * browser-side validation (schema re-run, per-field validators, client-run
+ * `refineEffect` refinements). Kept as parallel trees (see {@link
+ * SourcedErrors}) rather than tagging each message, so a UI can style sources
+ * differently and client revalidation can clear only its own tree, leaving
+ * server-reported failures in place until their field actually changes.
+ */
+type ErrorSource = "client" | "server";
+/** Parallel error trees, one per {@link ErrorSource}, plus their {@link mergeSourced} view. */
+interface SourcedErrors {
+  readonly client: FormErrors;
+  readonly server: FormErrors;
+}
+/** Both source trees empty. */
+declare const emptySourced: SourcedErrors;
+/** Combine both source trees into the single tree a UI reads (server first, then client). */
+declare function mergeSourced(sourced: SourcedErrors): FormErrors;
+/**
+ * Return new {@link SourcedErrors} with `source`'s tree updated at `path` via
+ * {@link replaceAt} (the other source's tree is untouched). Pure.
+ */
+declare function setSourceAt(sourced: SourcedErrors, source: ErrorSource, path: FormPath, messages: readonly string[]): SourcedErrors;
+/** Clear `source`'s messages at `path` (and nowhere else). Shorthand for {@link setSourceAt} with `[]`. */
+declare function clearSourceAt(sourced: SourcedErrors, source: ErrorSource, path: FormPath): SourcedErrors;
+declare namespace Field_d_exports {
+  export { AnyFieldDef, ArrayFieldDef, DecodedFromFields, EncodedFromFields, FieldDef, FieldsRecord, defaultEncodedValues, defaultItemAt, defaultValue, isArrayFieldDef, isFieldDef, makeArrayField, makeField, schemaAt };
+}
+/** A scalar field: a key bound to a leaf (or nested struct) schema. */
+interface FieldDef<K extends string, S extends Schema.Top> {
+  readonly _tag: "field";
+  readonly key: K;
+  readonly schema: S;
+}
+/** An array field: a key bound to an item schema; the field is a list of items. */
+interface ArrayFieldDef<K extends string, S extends Schema.Top> {
+  readonly _tag: "array";
+  readonly key: K;
+  readonly itemSchema: S;
+}
+/** Either field shape, with the key / schema types erased. */
+type AnyFieldDef = FieldDef<string, Schema.Top> | ArrayFieldDef<string, Schema.Top>;
+/** A record of fields, keyed by field name — the builder's accumulated shape. */
+type FieldsRecord = Record<string, AnyFieldDef>;
+/** Whether `def` is an {@link ArrayFieldDef}. */
+declare const isArrayFieldDef: (def: AnyFieldDef) => def is ArrayFieldDef<string, Schema.Top>;
+/** Whether `def` is a scalar {@link FieldDef}. */
+declare const isFieldDef: (def: AnyFieldDef) => def is FieldDef<string, Schema.Top>;
+/** Construct a scalar {@link FieldDef}. */
+declare const makeField: <K extends string, S extends Schema.Top>(key: K, schema: S) => FieldDef<K, S>;
+/** Construct an {@link ArrayFieldDef}. */
+declare const makeArrayField: <K extends string, S extends Schema.Top>(key: K, itemSchema: S) => ArrayFieldDef<K, S>;
+/** The encoded (form-input) data type for a record of fields. */
+type EncodedFromFields<T extends FieldsRecord> = { readonly [K in keyof T]: T[K] extends FieldDef<string, infer S> ? S["Encoded"] : T[K] extends ArrayFieldDef<string, infer S> ? ReadonlyArray<S["Encoded"]> : never; };
+/** The decoded (validated) data type for a record of fields. */
+type DecodedFromFields<T extends FieldsRecord> = { readonly [K in keyof T]: T[K] extends FieldDef<string, infer S> ? S["Type"] : T[K] extends ArrayFieldDef<string, infer S> ? ReadonlyArray<S["Type"]> : never; };
+/**
+ * Derive a blank *encoded* default from a schema AST: a struct recurses into
+ * its properties, an array seeds to `[]`, and any scalar seeds to `""` (an
+ * HTML input's empty value). Conservative by design — a value that will not
+ * decode cleanly is still a valid *starting* value the user edits.
+ */
+declare function defaultValue(schema: Schema.Top): unknown;
+/**
+ * Walk `schema`'s AST along `path` — through struct properties and array
+ * elements alike — and return the AST found there, or `undefined` if `path`
+ * doesn't resolve (a missing property, or a non-array indexed). Unlike a
+ * {@link FieldsRecord} lookup, this works for any nesting depth and for
+ * schemas built directly with `Form.make` (no builder involved).
+ */
+declare function schemaAt(schema: Schema.Top, path: FormPath): SchemaAST.AST | undefined;
+/**
+ * Derive a blank encoded item for the array field at `path` (any nesting
+ * depth) by walking `schema`'s AST there — the nested-array counterpart to
+ * {@link defaultValue}. Returns `""` when `path` doesn't resolve to an array.
+ */
+declare function defaultItemAt(schema: Schema.Top, path: FormPath): unknown;
+/** Seed a blank encoded value for every field: `[]` for arrays, `""` otherwise. */
+declare function defaultEncodedValues(fields: FieldsRecord): Record<string, unknown>;
+declare namespace FormBuilder_d_exports {
+  export { FormBuilder, TypeId, asyncRefinements, buildSchema, empty, filterOutputToFormIssues, isFormBuilder, make$2 as make, runAsyncRefinements };
+}
+/** Brand for a {@link FormBuilder}. */
+declare const TypeId: unique symbol;
+type TypeId = typeof TypeId;
+/** A synchronous cross-field refinement — becomes a struct-level schema check. */
+interface SyncRefinement {
+  readonly _tag: "sync";
+  readonly fn: (values: unknown) => Schema.FilterOutput;
+}
+/** An asynchronous cross-field refinement — run by the Effect validate path. */
+interface AsyncRefinement {
+  readonly _tag: "async";
+  readonly fn: (values: unknown) => Effect.Effect<Schema.FilterOutput, never, unknown>;
+}
+type Refinement = SyncRefinement | AsyncRefinement;
+/**
+ * A form assembled field by field. `TFields` accumulates the field record;
+ * `R` accumulates the schemas' decoding-service requirements. Immutable — every
+ * method returns a new builder.
+ */
+interface FormBuilder<TFields extends FieldsRecord, R> {
+  readonly [TypeId]: TypeId;
+  readonly fields: TFields;
+  readonly refinements: ReadonlyArray<Refinement>;
+  readonly _R?: R;
+  /** Add a scalar field from a {@link FieldDef}. */
+  addField<K extends string, S extends Schema.Top>(field: FieldDef<K, S>): FormBuilder<TFields & { readonly [key in K]: FieldDef<K, S>; }, R | S["DecodingServices"]>;
+  /** Add an array field from an {@link ArrayFieldDef}. */
+  addField<K extends string, S extends Schema.Top>(field: ArrayFieldDef<K, S>): FormBuilder<TFields & { readonly [key in K]: ArrayFieldDef<K, S>; }, R | S["DecodingServices"]>;
+  /** Add a scalar field from a key and schema. */
+  addField<K extends string, S extends Schema.Top>(key: K, schema: S): FormBuilder<TFields & { readonly [key in K]: FieldDef<K, S>; }, R | S["DecodingServices"]>;
+  /** Fold another builder's fields and refinements into this one. */
+  merge<TFields2 extends FieldsRecord, R2>(other: FormBuilder<TFields2, R2>): FormBuilder<TFields & TFields2, R | R2>;
+  /**
+   * Attach a synchronous whole-form validation. The predicate sees the decoded
+   * values and returns a {@link Schema.FilterOutput} (`undefined` / `true` to
+   * pass, a message / `{ path, issue }` / list to fail).
+   */
+  refine(predicate: (values: DecodedFromFields<TFields>) => Schema.FilterOutput): FormBuilder<TFields, R>;
+  /** Attach an asynchronous whole-form validation (run by the validate path). */
+  refineEffect<RD>(predicate: (values: DecodedFromFields<TFields>) => Effect.Effect<Schema.FilterOutput, never, RD>): FormBuilder<TFields, R | RD>;
+}
+/** Whether `u` is a {@link FormBuilder}. */
+declare const isFormBuilder: (u: unknown) => u is FormBuilder<FieldsRecord, unknown>;
+/** The empty builder — the starting point for {@link FormBuilder.addField}. */
+declare const make$2: FormBuilder<Record<never, never>, never>;
+/** Alias of {@link make} — the empty builder. */
+declare const empty: FormBuilder<Record<never, never>, never>;
+/**
+ * Collapse a builder into an Effect Schema: a `Schema.Struct` of the fields
+ * (array fields as `Schema.Array(item)`) with every synchronous refinement
+ * applied as a struct-level check. Ready for {@link module:effect-forms/Form}.
+ */
+declare function buildSchema<TFields extends FieldsRecord, R>(self: FormBuilder<TFields, R>): Schema.Codec<DecodedFromFields<TFields>, EncodedFromFields<TFields>, R>;
+/** The asynchronous refinements carried on a builder, as bare predicates. */
+declare function asyncRefinements<TFields extends FieldsRecord, R>(self: FormBuilder<TFields, R>): ReadonlyArray<(values: DecodedFromFields<TFields>) => Effect.Effect<Schema.FilterOutput, never, R>>;
+/**
+ * Run every asynchronous refinement on `self` against `values` and collect
+ * their failures as {@link FormIssue}s (empty when all pass). Runs them
+ * concurrently; requirements propagate on the `R` channel.
+ */
+declare function runAsyncRefinements<TFields extends FieldsRecord, R>(self: FormBuilder<TFields, R>, values: DecodedFromFields<TFields>): Effect.Effect<ReadonlyArray<FormIssue>, never, R>;
+declare namespace State_d_exports {
+  export { FormState, FormStateSchema, MakeFormStateOptions, isValid, make$1 as make, withError, withMessage };
+}
+/**
+ * A form snapshot.
+ *
+ * - `id` distinguishes multiple forms on one page.
+ * - `valid` is whether the last validation succeeded.
+ * - `posted` is whether this snapshot came from a submission (vs. a seeded
+ *   empty form) — drives "show errors only after submit" UIs.
+ * - `data` is the current values (typed output on success; posted values
+ *   merged over defaults on failure, so the form re-renders what the user
+ *   typed).
+ * - `errors` is the nested {@link FormErrors} tree.
+ * - `message` is an optional status payload (a free-form status payload).
+ * - `constraints` is the optional derived {@link InputConstraints} tree.
+ */
+interface FormState<A, Message = unknown> {
+  readonly id: string;
+  readonly valid: boolean;
+  readonly posted: boolean;
+  readonly data: A;
+  readonly errors: FormErrors;
+  readonly message?: Message | undefined;
+  readonly constraints?: InputConstraints | undefined;
+}
+/** Options for {@link make}. */
+interface MakeFormStateOptions<Message> {
+  readonly id?: string;
+  readonly valid?: boolean;
+  readonly posted?: boolean;
+  readonly errors?: FormErrors;
+  readonly message?: Message;
+  readonly constraints?: InputConstraints;
+}
+/** Build a {@link FormState} from data plus overrides. `valid` defaults to "no errors". */
+declare function make$1<A, Message = unknown>(data: A, options?: MakeFormStateOptions<Message>): FormState<A, Message>;
+/** Return a new state carrying `message` (and not otherwise changed). */
+declare function withMessage<A, Message>(state: FormState<A, Message>, message: Message): FormState<A, Message>;
+/**
+ * Return a new state with `message` added at `path` and `valid` forced to
+ * `false` — for attaching a
+ * server-side validation failure to a specific field after the schema passed.
+ */
+declare function withError<A, Message>(state: FormState<A, Message>, path: FormPath, message: string): FormState<A, Message>;
+/** Whether the state is valid. */
+declare const isValid: <A, Message>(state: FormState<A, Message>) => boolean;
+/** Effect Schema describing the JSON shape of {@link FormState} for transport. */
+declare function FormStateSchema<DataSchema extends Schema.Top>(data: DataSchema): Schema.Struct<{
+  readonly id: Schema.String;
+  readonly valid: Schema.Boolean;
+  readonly posted: Schema.Boolean;
+  readonly data: DataSchema;
+  readonly errors: Schema.$Record<Schema.String, Schema.Unknown>;
+  readonly message: Schema.optional<Schema.Unknown>;
+  readonly constraints: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+}>;
+declare namespace Form_d_exports {
+  export { Form, FormInput, FromBuilderOptions, MakeFormOptions, fromBuilder, make };
+}
+/** Everything {@link Form.validate} accepts. `null` / `undefined` mean "no submission". */
+type FormInput = FormData | URLSearchParams | Request | Record<string, unknown> | null | undefined;
+/** Options for {@link make}. */
+interface MakeFormOptions<S extends Schema.Top> {
+  /** Distinguishes multiple forms on a page. Defaults to `"default"`. */
+  readonly id?: string;
+  /** The blank-form values — what {@link Form.empty} seeds and the merge base on failure. */
+  readonly defaults: S["Type"];
+  /** Override the per-leaf message rendering. */
+  readonly leafFormatter?: LeafFormatter;
+  /** Constraint overrides deep-merged over the AST-derived tree. */
+  readonly constraints?: InputConstraints;
+  /** Derive {@link InputConstraints} from the schema AST (default `true`). */
+  readonly deriveConstraints?: boolean;
+}
+/** A schema bound to a form: a validator plus an empty-state factory. */
+interface Form<S extends Schema.Top, Message = unknown> {
+  readonly schema: S;
+  readonly id: string;
+  readonly constraints: InputConstraints;
+  /** Seed a blank, unposted form from the defaults. */
+  empty(overrides?: MakeFormStateOptions<Message>): FormState<S["Type"], Message>;
+  /** Parse a form body (no decode) into a structured object. */
+  parse(input: FormData | URLSearchParams | Record<string, unknown>): Record<string, unknown>;
+  /**
+   * Validate a submission into a {@link FormState}. Never fails on the error
+   * channel — schema failures become `errors` on the returned (invalid) state.
+   */
+  validate(input: FormInput): Effect.Effect<FormState<S["Type"], Message>, never, S["DecodingServices"]>;
+}
+/**
+ * Bind `schema` to a form. See the module docs for the contract. The returned
+ * {@link Form} is stateless and reusable across requests.
+ */
+declare function make<S extends Schema.Top, Message = unknown>(schema: S, options: MakeFormOptions<S>): Form<S, Message>;
+/** Options for {@link fromBuilder}. Like {@link MakeFormOptions} but `defaults` is optional. */
+interface FromBuilderOptions<TFields extends FieldsRecord> {
+  /** Distinguishes multiple forms on a page. Defaults to `"default"`. */
+  readonly id?: string;
+  /** Blank-form values. Defaults to a schema-derived encoded blank per field. */
+  readonly defaults?: EncodedFromFields<TFields>;
+  /** Override the per-leaf message rendering. */
+  readonly leafFormatter?: LeafFormatter;
+  /** Constraint overrides deep-merged over the AST-derived tree. */
+  readonly constraints?: InputConstraints;
+  /** Derive {@link InputConstraints} from the schema AST (default `true`). */
+  readonly deriveConstraints?: boolean;
+}
+/**
+ * Bind a {@link FormBuilder} to a {@link Form}. Collapses the builder to a
+ * schema (see {@link buildSchema}), then behaves like {@link make} — except its
+ * `validate` also runs the builder's *asynchronous* refinements after a
+ * successful decode, folding any failures into the same nested error tree. When
+ * `defaults` is omitted it is derived from the fields (blank encoded values).
+ */
+declare function fromBuilder<TFields extends FieldsRecord, R, Message = unknown>(builder: FormBuilder<TFields, R>, options?: FromBuilderOptions<TFields>): Form<Schema.Codec<DecodedFromFields<TFields>, EncodedFromFields<TFields>, R>, Message>;
+declare namespace FormData_d_exports {
+  export { FormBodySource, formDataToObject, parseFieldPath, requestToObject };
+}
+/**
+ * @copyright Thomas Foster
+ *
+ * Structured parsing of an HTML form body into a plain object the schema can
+ * decode.
+ *
+ * Browsers flatten structured data into `name=value` pairs using bracket /
+ * dot path notation (`author.name`, `author[name]`, `tags[0]`, `tags[]`).
+ * {@link formDataToObject} reverses that into a nested object / array tree —
+ * the framework-neutral step that turns a form body into structured data, before handing it
+ * to a validator. Coercion (strings → numbers / booleans / dates) is then the
+ * schema's job: decode the result with a schema built from coercing leaves
+ * (`Schema.FiniteFromString`, `Schema.BooleanFromString`, the {@link
+ * module:effect-forms/Coerce} helpers, …).
+ *
+ * `File` values pass through untouched; repeated bare keys collapse into an
+ * array. The parser is total and never throws.
+ *
+ * @module effect-forms/FormData
+ */
+/** Anything that can be parsed into a structured form object. */
+type FormBodySource = FormData | URLSearchParams | Iterable<readonly [string, FormDataEntryValue | string]>;
+/**
+ * Split a flat field name into its path tokens. Supports dot notation
+ * (`a.b`), bracket notation (`a[b]`, `a[0]`), and the trailing append form
+ * (`a[]`, represented by an empty-string token). `"a[b][0]"` → `["a","b","0"]`;
+ * `"a.b[]"` → `["a","b",""]`.
+ */
+declare function parseFieldPath(name: string): string[];
+/**
+ * Parse a form body into a nested object / array tree. Field names use dot or
+ * bracket path notation (see {@link parseFieldPath}); repeated bare keys
+ * become arrays; `File` values pass through. The result is ready to hand to
+ * `Schema.decodeUnknown` with a schema whose leaves coerce the string inputs.
+ */
+declare function formDataToObject(source: FormBodySource): Record<string, unknown>;
+/** Read and parse a `Request`'s form body. Errors (e.g. wrong content-type) reject. */
+declare function requestToObject(request: Request): Promise<Record<string, unknown>>;
+declare namespace Mode_d_exports {
+  export { FormMode, ParsedMode, RevalidateMode, parse };
+}
+/** What re-validates a posted form as the user keeps editing. See {@link ParsedMode.revalidate}. */
+type RevalidateMode = "onChange" | "onBlur" | "never";
+/**
+ * How a form decides when to validate, and whether it auto-submits.
+ *
+ * - `onSubmit` (the default) cannot auto-submit or debounce.
+ * - `onBlur` may auto-submit; debounce is not meaningful.
+ * - `onChange` may auto-submit and may debounce.
+ *
+ * `revalidate` is independent of `validation` and applies to every mode —
+ * see the module docs.
+ */
+type FormMode = ({
+  readonly validation?: "onSubmit";
+  readonly autoSubmit?: false;
+  readonly debounce?: never;
+} | {
+  readonly validation: "onBlur";
+  readonly autoSubmit?: boolean;
+  readonly debounce?: never;
+} | {
+  readonly validation: "onChange";
+  readonly debounce?: Duration.Input;
+  readonly autoSubmit?: boolean;
+}) & {
+  readonly revalidate?: RevalidateMode;
+};
+/** The fully-resolved form of a {@link FormMode} — every field decided. */
+interface ParsedMode {
+  readonly validation: "onSubmit" | "onBlur" | "onChange";
+  /** Debounce in milliseconds, or `null` for no debounce. */
+  readonly debounce: number | null;
+  readonly autoSubmit: boolean;
+  /** What re-validates the form once it has been posted at least once. Defaults to `"onChange"`. */
+  readonly revalidate: RevalidateMode;
+}
+/**
+ * Normalise a {@link FormMode} into a {@link ParsedMode}. An absent mode is
+ * `onSubmit`. `debounce` is resolved to milliseconds and only applies in
+ * `onChange`; `autoSubmit` is only honoured for `onBlur` / `onChange`;
+ * `revalidate` defaults to `"onChange"` (TanStack's / RHF's default
+ * post-submit behaviour) regardless of the primary `validation` mode.
+ */
+declare function parse(mode?: FormMode): ParsedMode;
+declare namespace Result_d_exports {
+  export { FormActionData, FormActionResult, FormErrorResult, FormFailure, FormRedirect, FormSuccess, errorResult, failure, redirect, success };
+}
+/** The submission validated and the command ran; carries the resulting state. */
+interface FormSuccess<A, Message> {
+  readonly _tag: "Success";
+  readonly status: number;
+  readonly state: FormState<A, Message>;
+}
+/** The submission was rejected (validation or a user-fixable command failure). */
+interface FormFailure<A, Message> {
+  readonly _tag: "Failure";
+  readonly status: number;
+  readonly state: FormState<A, Message>;
+}
+/** The handler asks the client to navigate elsewhere (post-success redirect). */
+interface FormRedirect {
+  readonly _tag: "Redirect";
+  readonly status: number;
+  readonly location: string;
+}
+/** An unexpected (non-user-fixable) error: surface it, don't bind it to fields. */
+interface FormErrorResult {
+  readonly _tag: "Error";
+  readonly status: number;
+  readonly message: string;
+}
+/** The outcome of a form submission. */
+type FormActionResult<A, Message = unknown> = FormSuccess<A, Message> | FormFailure<A, Message> | FormRedirect | FormErrorResult;
+/**
+ * The data a server form action returns to the client on a non-redirect
+ * outcome — the wire contract a client adapter applies back to its store. A
+ * validation failure carries the {@link FormState} (`form`); an unexpected
+ * error carries a root `message`.
+ */
+interface FormActionData<A = unknown, Message = unknown> {
+  /** The form state (nested errors + posted values) for the client to apply. */
+  readonly form?: FormState<A, Message>;
+  /** A root-level message for an unexpected (non-field) failure. */
+  readonly message?: string;
+}
+/** Construct a {@link FormSuccess} (default status 200). */
+declare const success: <A, Message>(state: FormState<A, Message>, status?: number) => FormActionResult<A, Message>;
+/** Construct a {@link FormFailure} (default status 400). */
+declare const failure: <A, Message>(state: FormState<A, Message>, status?: number) => FormActionResult<A, Message>;
+/** Construct a {@link FormRedirect} (default status 303). */
+declare const redirect: <A, Message>(location: string, status?: number) => FormActionResult<A, Message>;
+/** Construct a {@link FormErrorResult} (default status 500). */
+declare const errorResult: <A, Message>(message: string, status?: number) => FormActionResult<A, Message>;
+declare namespace Validate_d_exports {
+  export { AsyncFieldValidator, FieldTrigger, FieldValidators, ResolvedFieldTrigger, SyncFieldValidator, ValidationResult, resolveFieldTrigger, runAsyncFieldValidator, runSyncFieldValidator, validateValue, validateValueSync };
+}
+/** The outcome of validating a value against a schema. */
+type ValidationResult<A> = {
+  readonly valid: true;
+  readonly data: A;
+} | {
+  readonly valid: false;
+  readonly errors: FormErrors;
+  readonly issues: ReadonlyArray<FormIssue>;
+};
+/**
+ * Decode `input` through `schema`, returning a {@link ValidationResult} on the
+ * success channel (decode failures become `valid: false`, not an Effect
+ * failure). Decoding-service requirements propagate on the `R` channel.
+ */
+declare function validateValue<S extends Schema.Top>(schema: S, input: unknown, format?: LeafFormatter): Effect.Effect<ValidationResult<S["Type"]>, never, S["DecodingServices"]>;
+/**
+ * Synchronous {@link validateValue} for schemas with no decoding-service
+ * requirements (`R = never`) and no async decoding — the common case for plain
+ * form schemas. {@link validateValue} never fails on the error channel, so
+ * running it with {@link Effect.runSync} is total.
+ */
+declare function validateValueSync<S extends Schema.Top>(schema: S, input: unknown, format?: LeafFormatter): ValidationResult<S["Type"]>;
+/**
+ * A synchronous per-field validator — TanStack Form's `validators.onChange` /
+ * `onBlur` shape. Sees the field's decoded value and returns a {@link
+ * Schema.FilterOutput} (`undefined` / `true` to pass, a message / issue /
+ * list to fail), the same vocabulary a schema `check` or a {@link
+ * module:effect-forms/FormBuilder} `refine` predicate uses.
+ */
+type SyncFieldValidator<A> = (value: A) => Schema.FilterOutput;
+/**
+ * An asynchronous per-field validator — TanStack Form's `onChangeAsync` /
+ * `onBlurAsync`. An Effect (not a `Promise`) so its `R` channel can demand
+ * services (an API client, a cache) the way a {@link
+ * module:effect-forms/FormBuilder} `refineEffect` refinement does; a caller
+ * running this client-side supplies `R` via a `Layer` / runtime, or keeps it
+ * `never` for a plain `fetch`-based check.
+ */
+type AsyncFieldValidator<A, R = never> = (value: A) => Effect.Effect<Schema.FilterOutput, never, R>;
+/**
+ * The validators one field declares, mirroring TanStack Form's per-field
+ * `validators` option. `asyncDebounceMs` (default `0`, meaning no debounce)
+ * governs both async variants; see {@link runAsyncFieldValidator} for how the
+ * debounce and cancellation actually work.
+ */
+interface FieldValidators<A, R = never> {
+  readonly onChange?: SyncFieldValidator<A>;
+  readonly onBlur?: SyncFieldValidator<A>;
+  readonly onChangeAsync?: AsyncFieldValidator<A, R>;
+  readonly onBlurAsync?: AsyncFieldValidator<A, R>;
+  readonly asyncDebounceMs?: number;
+}
+/**
+ * Run a {@link SyncFieldValidator}, folding its {@link Schema.FilterOutput}
+ * into {@link FormIssue}s (empty on success). Total — a sync field validator
+ * cannot fail the Effect error channel.
+ */
+declare function runSyncFieldValidator<A>(validator: SyncFieldValidator<A>, value: A): ReadonlyArray<FormIssue>;
+/**
+ * Build the Effect an {@link AsyncFieldValidator} run is: sleep `debounceMs`
+ * (a no-op at `0`, the default), then run `validator` and fold its output
+ * into {@link FormIssue}s.
+ *
+ * The debounce is a plain {@link Effect.sleep}, so it rides Effect's `Clock`
+ * — deterministic and instantly-advanceable under `TestClock` in tests, real
+ * time otherwise (no `setTimeout` bookkeeping for a caller to manage).
+ * "Latest wins" falls out of ordinary fiber interruption: a caller re-running
+ * this on every keystroke forks a fresh fiber per call and interrupts the
+ * previous one before forking the next — interrupting mid-sleep skips the
+ * validator entirely (a true debounce, not just a discarded stale result),
+ * and interrupting mid-validator aborts whatever the validator was doing
+ * (e.g. an in-flight `fetch` wrapped as an Effect).
+ */
+declare function runAsyncFieldValidator<A, R>(validator: AsyncFieldValidator<A, R>, value: A, debounceMs?: number): Effect.Effect<ReadonlyArray<FormIssue>, never, R>;
+/** Which trigger a {@link FieldValidators} sync/async pair reacts to. */
+type FieldTrigger = "change" | "blur";
+/** The validator(s) (if any) that apply for one field trigger — see {@link resolveFieldTrigger}. */
+interface ResolvedFieldTrigger<A, R = never> {
+  readonly sync: SyncFieldValidator<A> | undefined;
+  readonly async: AsyncFieldValidator<A, R> | undefined;
+  readonly asyncDebounceMs: number;
+}
+/**
+ * Pick `validators`' sync/async pair for `trigger` (TanStack's `onChange` /
+ * `onBlur` vs `onChangeAsync` / `onBlurAsync`). A reactive store calls this
+ * once per trigger instead of repeating the trigger ternary at each call
+ * site — the pure decision half of what {@link module:effect-forms-svelte/FormStore}'s
+ * field-trigger dispatch runs.
+ */
+declare function resolveFieldTrigger<A, R = never>(validators: FieldValidators<A, R> | undefined, trigger: FieldTrigger): ResolvedFieldTrigger<A, R>;
+//#endregion
+export { Coerce_d_exports as Coerce, Command_d_exports as Command, Constraints_d_exports as Constraints, Errors_d_exports as Errors, Field_d_exports as Field, Form_d_exports as Form, FormBuilder_d_exports as FormBuilder, FormData_d_exports as FormData, Issues_d_exports as Issues, Mode_d_exports as Mode, Path_d_exports as Path, Result_d_exports as Result, State_d_exports as State, Validate_d_exports as Validate };
+//# sourceMappingURL=index.d.ts.map