react-f0rm 1.2.0 → 1.4.0

package/dist/standard-schema-CYbnugL7.d.ts

@@ -0,0 +1,1184 @@
+import { EventEmitter } from '@for-fun/event-emitter';
+
+/** A single Standard Schema issue. */
+type StandardSchemaIssue = {
+    readonly message: string;
+    readonly path?: ReadonlyArray<PropertyKey | {
+        readonly key: PropertyKey;
+    }> | undefined;
+};
+/** The union Standard Schema's `validate` resolves to. */
+type StandardSchemaResult<Output = unknown> = {
+    readonly value: Output;
+    readonly issues?: undefined;
+} | {
+    readonly issues: ReadonlyArray<StandardSchemaIssue>;
+};
+/**
+ * Structural Standard Schema v1. `types` is optional in the spec but
+ * implemented by zod v3.24+/v4, valibot v1 and arktype — it is what
+ * {@link InferSchemaValues} and `createForm`'s `TValues` inference read.
+ */
+type StandardSchemaV1<Input = unknown, Output = Input> = {
+    readonly '~standard': {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: Input) => StandardSchemaResult<Output> | Promise<StandardSchemaResult<Output>>;
+        readonly types?: {
+            readonly input: Input;
+            readonly output: Output;
+        };
+    };
+};
+/**
+ * The values type a Standard Schema produces: the `Output` of its
+ * `~standard.types`, resolved structurally without importing the schema
+ * library. Coercions/transforms land in the output — `z.coerce.date()`
+ * infers `Date`, not `string`. `never` when the schema does not expose
+ * `types` (pass an explicit `TValues` then).
+ *
+ * @example
+ * ```ts
+ * const schema = z.object({email: z.string().email()});
+ * type Values = InferSchemaValues<typeof schema>; // {email: string}
+ * const form = useForm<InferSchemaValues<typeof schema>>();
+ * ```
+ */
+type InferSchemaValues<S> = S extends {
+    readonly '~standard': {
+        readonly types: {
+            readonly output: infer Out;
+        };
+    };
+} ? Out : never;
+/**
+ * Does the value implement the Standard Schema v1 props? A plain boolean
+ * predicate, not a type guard: narrowing a
+ * `Fn | StandardSchemaV1<In, Out>` union through the guard fails either
+ * way (a generics-narrowing guard is contravariance-blocked, an
+ * intersection guard keeps both members) — call sites cast after the
+ * check instead.
+ */
+declare function hasStandardProps(schema: any): boolean;
+/**
+ * Field-level Standard Schema adapter: validate a single value with any
+ * schema implementing '~standard' and map every issue to a FieldError, so
+ * a value breaking several rules surfaces all of them (setErrorByPath
+ * stores the array; error/errorObject readers still see the first).
+ * The schema's parsed output is validation-only here — field validators
+ * never rewrite the value; form-level schemas own coercion.
+ */
+declare function schemaToFieldValidator(schema: StandardSchemaV1<any, any>): Validator;
+/**
+ * Form-level Standard Schema adapter: validate the whole values object and
+ * return a ValidationOutcome. On failure `errors` carries the nested shape
+ * Options.validate expects ({a: {b: FieldError[]}}; ensureValidate flattens
+ * it back to per-field errors, keeping every issue of a path). Issues
+ * without a path are form-level errors and land on the FORM_ERROR key.
+ * On success `values` carries the schema's parsed output (coerce/transform
+ * results included), which the form stores as its parsedValues baseline —
+ * the layer getValues reads above initialValues.
+ *
+ * `createForm({validate: schema})` wraps the schema through this adapter
+ * automatically (no resolver import needed), and `TValues` infers from
+ * the schema's output type.
+ */
+declare function schemaToFormValidator<T extends Record<string, any>>(schema: StandardSchemaV1<any, T>): (values: T) => Promise<ValidationOutcome<T>>;
+
+type PathSegments = (string | number)[];
+type Name = string | PathSegments;
+type Path = {
+    value: PathSegments;
+    key: string;
+};
+
+/**
+ * Compile-time field path utilities: `FieldPath<T>` enumerates the valid
+ * path strings for a values shape `T` ('a', 'a.b', 'a[0]', 'a[b]', ...),
+ * and `PathValue<T, P>` resolves the leaf type a path points at.
+ * The grammar mirrors the paths accepted at runtime by `normalizePath`:
+ * numeric segments are bracket-only ('a[0]', never 'a.0' — dotted
+ * numerics throw a TypeError at runtime).
+ */
+/** `true` only for the `any` type (`0 extends 1 & any`). */
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+/**
+ * Opt-in registry of value types the path types treat as opaque leaves.
+ * `FieldPath<T>` stops descending into a registered type — a `Date`,
+ * `Dayjs` or class instance in the values shape is a value, not a field
+ * tree — and `PathValue` resolves the field itself to that type. Merge
+ * entries in via declaration merging:
+ *
+ * ```ts
+ * // app.d.ts
+ * declare module 'react-f0rm' {
+ *   interface OpaqueTypes {
+ *     dayjs: Dayjs;
+ *     date: Date;
+ *   }
+ * }
+ * ```
+ *
+ * Empty by default: every object-typed leaf keeps its historical,
+ * navigable behavior (react-hook-form's same-named registry is opt-in
+ * too). `keyof` of an empty interface is `never`, so the registry reads
+ * as a no-op until an entry lands.
+ */
+interface OpaqueTypes {
+}
+/** The union of every leaf type registered in {@link OpaqueTypes} —
+ * `never` until an application merges entries in. */
+type OpaqueLeaf = OpaqueTypes[keyof OpaqueTypes];
+/** Depth countdown: Prev[9] = 8 ... Prev[1] = 0, Prev[0] = never stops recursion. */
+type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+/** Paths are capped at 10 segments to keep instantiation depth bounded. */
+type MaxDepth = 9;
+/**
+ * Valid path continuations after a segment: `.k` / `[k]` / `[0]`,
+ * optionally followed by deeper continuations into the child node.
+ * Numeric segments are bracket-only (`.0` throws at runtime); object
+ * keys that are themselves numeric strings likewise enumerate just the
+ * bracket subscript.
+ */
+type Continue<T, D extends number> = [D] extends [never] ? never : IsAny<T> extends true ? string : T extends OpaqueLeaf ? never : T extends Primitive | Function ? never : T extends readonly (infer U)[] ? `[${number}]` | `[${number}]${Continue<U, Prev[D]>}` : {
+    [K in Extract<keyof T, string>]: (K extends `${number}` ? never : `.${K}`) | `[${K}]` | (K extends `${number}` ? never : `.${K}${Continue<T[K], Prev[D]>}`) | `[${K}]${Continue<T[K], Prev[D]>}`;
+}[Extract<keyof T, string>];
+/**
+ * Every valid field path string for a values shape `T`.
+ *
+ * Enumeration is capped at 10 segments ({@link MaxDepth}) to keep
+ * instantiation depth bounded: paths below the cap are not part of this
+ * type, so their call sites fall back to `any` through
+ * {@link PathValueOf} instead of erroring. Types registered in
+ * {@link OpaqueTypes} stop recursion entirely — register deep object
+ * leaves (Date, Dayjs, class instances) there instead of relying on the
+ * cap.
+ * @example FieldPath<{a: {b: string}}> // 'a' | 'a.b' | 'a[b]'
+ */
+type FieldPath<T> = IsAny<T> extends true ? string : T extends OpaqueLeaf ? never : T extends Primitive | Function ? never : T extends readonly (infer U)[] ? `[${number}]` | `[${number}]${Continue<U, MaxDepth>}` : {
+    [K in Extract<keyof T, string>]: K extends `${number}` ? never : K | `${K}${Continue<T[K], MaxDepth>}`;
+}[Extract<keyof T, string>];
+/** Resolve `T[K]` for one bare segment: array index -> element, object key -> value. */
+type Lookup<T, K extends string> = K extends `${number}` ? T extends readonly (infer U)[] ? U : never : K extends keyof T ? T[K] : never;
+/** One dot-separated chunk: a bare segment plus any `[k]` / `[0]` suffixes. */
+type ChunkValue<T, C extends string> = C extends `${infer Key}[${infer Tail}` ? ChunkSuffix<Lookup<T, Key>, `[${Tail}`> : Lookup<T, C>;
+type ChunkSuffix<T, S extends string> = S extends `[${infer Key}]${infer Rest}` ? Rest extends '' ? Lookup<T, Key> : PathOf<Lookup<T, Key>, Rest> : never;
+/** Resolve the value type the path string `P` points at inside `T`. */
+type PathOf<T, P extends string> = P extends '' ? never : P extends `[${infer Key}]${infer Rest}` ? Rest extends '' ? Lookup<T, Key> : PathOf<Lookup<T, Key>, Rest> : P extends `.${infer Rest}` ? PathOf<T, Rest> : P extends `${infer Chunk}.${infer Rest}` ? PathOf<ChunkValue<T, Chunk>, Rest> : ChunkValue<T, P>;
+/**
+ * The value type at path `P` of a values shape `T`.
+ * @example PathValue<{a: {b: string}}, 'a.b'> // string
+ */
+type PathValue<T, P extends FieldPath<T>> = PathOf<T, P & string>;
+/**
+ * The value type at path `P` of `T`, or `any` when `P` is not a known
+ * field path (plain `string` / segment-array calls keep their old behavior).
+ */
+type PathValueOf<T, P> = P extends FieldPath<T> ? PathValue<T, Extract<P, FieldPath<T>>> : any;
+/**
+ * The element type of the array a path points at inside a values shape:
+ * `ArrayItemOf<{tags: Item[]}, 'tags'>` is `Item`. Non-array leaves
+ * resolve to the leaf type itself; unknown paths (plain `string`,
+ * segment arrays) fall back to `any` — the same wide-name escape hatch
+ * {@link PathValueOf} keeps.
+ */
+type ArrayItemOf<T, P> = P extends FieldPath<T> ? PathValue<T, Extract<P, FieldPath<T>>> extends readonly (infer U)[] ? U : PathValue<T, Extract<P, FieldPath<T>>> : any;
+
+/** Type tag of a failed rule, as stored on the resulting FieldError. */
+type RuleType = 'required' | 'min' | 'max' | 'minLength' | 'maxLength' | 'pattern';
+/**
+ * Declarative field rules — a subset of react-hook-form's `register` rules.
+ *
+ * Failed rules land in the form's error state as FieldErrors (`type` is the
+ * rule name) instead of only surfacing through the browser's validity
+ * bubble, so any design system can render the messages uniformly.
+ */
+type FieldRules = {
+    /**
+     * Fails on empty values: `''`, `undefined`, `null` or an empty array
+     * (`0` and `false` count as filled) — react-hook-form's `required`
+     * semantics. A string is the error message; `true` uses the default.
+     * When it fails, the remaining rules are skipped — an empty value
+     * reports only its required error.
+     */
+    required?: string | true;
+    /** Fails when `Number(value)` is below this bound; `NaN` values skip. */
+    min?: number;
+    /** Fails when `Number(value)` is above this bound; `NaN` values skip. */
+    max?: number;
+    /** Fails when a string value is shorter than this, or an array has
+     * fewer entries; other values skip. */
+    minLength?: number;
+    /** Fails when a string value is longer than this, or an array has more
+     * entries; other values skip. */
+    maxLength?: number;
+    /** Fails when the value does not match `pattern.value`. */
+    pattern?: {
+        value: RegExp;
+        message: string;
+    };
+    /**
+     * Custom rule callbacks — react-hook-form's `register({validate})`
+     * shape: one function, or a record of named functions. Each runs after
+     * the declarative checks, and only when they passed (`required` failing
+     * short-circuits the rest, RHF's first-error semantics). A returned
+     * error keeps its message; its `type` becomes the record key
+     * (`'validate'` for the single-function form) so consumers can switch
+     * on `error.type`. Sync-only — async checks belong in the field's
+     * `validate` option.
+     */
+    validate?: SyncValidator | Record<string, SyncValidator>;
+    /**
+     * Overrides the message per rule type — `min`, `max`, `minLength`,
+     * `maxLength` defaults and pattern's inline `message` alike — e.g. for
+     * centralizing or localizing messages.
+     */
+    messages?: Partial<Record<Exclude<RuleType, 'required'>, string>>;
+};
+
+/** Options accepted by {@link setFocus}. All flags default to `false`. */
+type SetFocusOptions = {
+    /** Select the field's text after focusing it. Bound fields call
+     * `select()` on their element; elements without one (custom `as`
+     * components) just focus. */
+    shouldSelect?: boolean;
+};
+/**
+ * Programmatically focus a bound field's element (e.g. the <Field>'s
+ * input).
+ *
+ * Rides the same 'focusError' event channel a failed handleSubmit uses to
+ * focus the first errored field: the payload is the target's path key,
+ * with the focus options as a second, backward-compatible argument (older
+ * subscribers declared with a single `key` parameter simply ignore it).
+ * Being event-driven, it is a silent no-op when the field is unmounted or
+ * nothing subscribes — unknown names never throw.
+ *
+ * @param form form instance
+ * @param name field name (dot path or segments path)
+ * @param options focus options
+ */
+declare function setFocus(form: Form, name: Name, options?: SetFocusOptions): void;
+
+/** Reserved top-level path segment for form-level errors. The Standard
+ * Schema form-level adapter lands path-less issues under this key; the
+ * exported constant replaces the magic string, and readers consume it via
+ * getError(form, FORM_ERROR) / getFieldErrors(form, FORM_ERROR). */
+declare const FORM_ERROR = "_form";
+/** When a field is validated:
+ * - `'onSubmit'` (default): only on submit
+ * - `'onBlur'`: when the field loses focus
+ * - `'onChange'`: on every change
+ * - `'onTouched'`: on first blur, then on every change
+ * - `'all'`: on both change and blur
+ */
+/** Brand marking a form-level validate result as a structured
+ * {@link ValidationOutcome} (parsed values and/or errors) rather than a
+ * plain nested error record. Symbols cannot collide with user error
+ * records, so detection is an exact `VALIDATION_OUTCOME in result`. */
+declare const VALIDATION_OUTCOME: unique symbol;
+/** Structured form-level validate result: `errors` uses the same nested
+ * shape a plain error record uses, `values` is the schema's parsed output
+ * (coerce/transform results included). Either side may be omitted. */
+/**
+ * Get field error
+ * @param form
+ * @param name
+ * @return FieldError object or undefined
+ */
+declare function getError<T extends Record<string, any> = any, P extends FieldPath<T> | PathSegments = FieldPath<T> | PathSegments>(form: Form<T>, name: P): FieldError | undefined;
+/**
+ * Get field error by path
+ * @param form
+ * @param path
+ * @return first FieldError of the field, or undefined
+ */
+declare function getErrorByPath({ errors }: Form, path: Path): FieldError | undefined;
+/**
+ * Get all errors of a field
+ * @param form
+ * @param name
+ * @return every error registered for the field (insertion order); an empty
+ *         array when the field has none
+ */
+declare function getFieldErrors<T extends Record<string, any> = any, P extends FieldPath<T> | PathSegments = FieldPath<T> | PathSegments>(form: Form<T>, name: P): FieldError[];
+/**
+ * Get all errors of a field by path
+ * @param form
+ * @param path
+ * @return every error registered for the field (insertion order); an empty
+ *         array when the field has none
+ */
+declare function getFieldErrorsByPath({ errors }: Form, path: Path): FieldError[];
+/**
+ * Get all errors
+ * @param form
+ * @return array of {path, type, message} entries, in insertion order; path
+ *         is the user-facing dotted field path ('a.b', 'list.0'), and a
+ *         field holding several errors contributes one entry per error
+ */
+declare function getErrors({ errors }: Form): FieldErrorEntry[];
+/**
+ * Convert a {@link FieldPath} string to the key form error records use at
+ * runtime: paths spell array access with brackets ('items[0].name') while
+ * {@link getErrorsRecord} keys are dot-joined segments ('items.0.name').
+ * The declared keys follow the runtime, so typed reads
+ * (`errors['items.0.name']`) match what the record actually holds. Quoted
+ * segments ('items["0"]') drop their quotes like the parser does.
+ *
+ * Public so consumers can name the key style in their own types —
+ * `const key: DottedPath<'items[0].name'> = 'items.0.name'`.
+ */
+type DottedPath<P extends string> = P extends `${infer H}[${infer N}]${infer R}` ? `${H extends '' ? '' : `${H}.`}${N extends `"${infer K}"` | `'${infer K}'` ? K : N}${DottedPath<R>}` : P;
+/**
+ * Every error as one record keyed by user-facing dotted path, typed
+ * against the values shape — react-hook-form's `FieldErrors<T>` shape
+ * (per-key values are optional there too). Keys follow the runtime form:
+ * dotted paths ('a.b', 'list.0'), plus the {@link FORM_ERROR} slot for
+ * form-level errors. Values are the stored FieldError[] arrays shared
+ * with the form, so treat the whole result as read-only.
+ */
+type FieldErrors<T extends Record<string, any> = any> = Partial<Record<DottedPath<Extract<FieldPath<T>, string>>, FieldError[]>> & {
+    [FORM_ERROR]?: FieldError[];
+};
+/** `true` only for the `any` type (the same probe {@link FieldPath}
+ * uses), so the tree of an untyped form degrades to `any` instead of an
+ * infinite mapped-type expansion. */
+type IsAnyTree<T> = 0 extends 1 & T ? true : false;
+type TreePrimitive = null | undefined | string | number | boolean | symbol | bigint;
+/** One level of the nested error tree: arrays become arrays of the item's
+ * tree, objects recurse per key, everything else — primitives, functions,
+ * registered {@link OpaqueTypes} leaves, and the common opaque DOM/date
+ * containers (Date, File, FileList, Map, Set) — is a leaf holding the
+ * stored FieldError[] (shared with the form — treat as read-only). */
+type FieldErrorsTreeNode<T> = IsAnyTree<T> extends true ? any : T extends OpaqueTypes[keyof OpaqueTypes] ? FieldError[] : T extends TreePrimitive | Function | Date | File | FileList | Map<any, any> | Set<any> ? FieldError[] : T extends ReadonlyArray<infer E> ? FieldErrorsTreeNode<E>[] : {
+    [K in keyof T]?: FieldErrorsTreeNode<T[K]>;
+};
+/**
+ * Every error as one nested object following the values tree —
+ * react-hook-form's `formState.errors` shape with typed optional chains
+ * (`errors.items?.[0]?.name`), the readable counterpart of
+ * {@link FieldErrors}' flat dotted keys. Array positions become array
+ * indices (holes stay absent), object fields become optional keys,
+ * leaves hold the stored FieldError[] arrays shared with the form — treat
+ * the whole result as read-only. The {@link FORM_ERROR} slot holds
+ * form-level errors at the top level.
+ *
+ * One conflict is resolved by insertion order: a row-level error at
+ * `items[0]` and a field error at `items[0].name` cannot both occupy the
+ * `items[0]` slot, so whichever landed later owns it (react-hook-form's
+ * nested `setError` clobbers the same way). The flat record never
+ * conflicts — read it when both coexist.
+ */
+type FieldErrorsTree<T = any> = FieldErrorsTreeNode<T> & {
+    [FORM_ERROR]?: FieldError[];
+};
+/**
+ * Get every error as one record keyed by user-facing dotted path
+ * ('a.b', 'list.0') — react-hook-form's `formState.errors` shape. Values
+ * are the stored FieldError[] arrays shared with the form, so treat the
+ * whole result as read-only. Memoized per form with the same
+ * version-bump/read pattern {@link getValues} uses: every error write
+ * bumps {@link bumpErrorsVersion}, consecutive reads hand back one stable
+ * reference, so {@link useErrors} / `useFormState().errors` only re-render
+ * when an error actually changed.
+ *
+ * @param form
+ */
+declare function getErrorsRecord<T extends Record<string, any> = any>(form: Form<T>): FieldErrors<T>;
+/**
+ * Get every error as one nested object following the values tree
+ * (`errors.items[0].name` reads — the shape react-hook-form's
+ * `formState.errors` uses), the optional-chaining counterpart of
+ * {@link getErrorsRecord}'s flat dotted keys. Array positions become
+ * array indices, leaves hold the stored FieldError[] arrays shared with
+ * the form — treat the whole result as read-only. Memoized alongside the
+ * record through the same version-bump/read pattern, so {@link
+ * useErrorsTree} only re-renders when an error actually changed.
+ *
+ * @param form
+ */
+declare function getErrorsTree<T extends Record<string, any> = any>(form: Form<T>): FieldErrorsTree<T>;
+/**
+ * Convert a field path (bracket spelling, the `name` every API takes) into
+ * the dotted key {@link getErrorsRecord} / {@link getErrors} use:
+ * `'items[0].name'` → `'items.0.name'`. Useful for error-record reads —
+ * `errors[fieldPathToDottedKey(name)]` — and for centralizing the
+ * translation when the two spellings meet in one component.
+ */
+declare function fieldPathToDottedKey(name: Name): string;
+/**
+ * Convert a dotted errors-record key back into bracket path spelling:
+ * `'items.0.name'` → `'items[0].name'` — the form every API takes, so the
+ * result feeds straight into `getError(form, …)` / `<Field name=…>`.
+ *
+ * Numeric-shaped segments become bracket segments; everything else stays
+ * dot-joined. Inherently lossy by the record's own convention: the dotted
+ * key cannot distinguish a segment containing a literal dot (a quoted path
+ * like `a["b.c"]` joins to the same `'a.b.c'` as `a.b.c`) — for such paths
+ * keep the bracket spelling and use {@link fieldPathToDottedKey} for the
+ * record read instead.
+ */
+declare function dottedKeyToFieldPath(key: string): string;
+/**
+ * Get first error message
+ * @param form
+ * @return first error's message string, or undefined when there are no errors
+ */
+declare function getFirstError({ errors }: Form): string | undefined;
+/** Snapshot of one field's aggregated state, as {@link getFieldState}
+ * returns it. `errors` is the stored array shared with the form — treat it
+ * as read-only, like every {@link getFieldErrors} result. */
+/** Options accepted by {@link setError}. */
+type SetErrorOptions = {
+    /**
+     * Focus the named field's element after the error lands (react-hook-form's
+     * `setError` `shouldFocus`). Rides the same 'focusError' channel
+     * `setFocus` and a failed submit's auto-focus use: only mounted bound
+     * fields react, unmounted ones are silent no-ops.
+     */
+    shouldFocus?: boolean;
+};
+/**
+ * Set field error
+ * @param form
+ * @param name
+ * @param error string is normalized to {type: 'custom', message}; a
+ *        FieldError object is stored as-is; an array holds several errors
+ *        (falsy items dropped, strings normalized); undefined clears
+ * @param options {@link SetErrorOptions} — `shouldFocus` focuses the field
+ *        after the error lands
+ */
+declare function setError<T extends Record<string, any> = any, P extends FieldPath<T> | PathSegments = FieldPath<T> | PathSegments>(form: Form<T>, name: P, error: string | FieldError | (string | FieldError)[] | undefined, options?: SetErrorOptions): void;
+/**
+ * Set field error
+ * @param form
+ * @param path
+ * @param error string is normalized to {type: 'custom', message}; a
+ *        FieldError object is stored as-is; an array holds several errors
+ *        (falsy items dropped, strings normalized); undefined clears
+ * @param options {@link SetErrorOptions} — `shouldFocus` focuses the field
+ *        after the error lands
+ */
+declare function setErrorByPath(form: Form, path: Path, error: string | FieldError | (string | FieldError)[] | undefined, options?: SetErrorOptions): void;
+/**
+ * Clear errors
+ * @param form
+ * @param name a single path or a list of paths; omit to clear every error
+ */
+declare function clearErrors(form: Form, name?: Name | Name[]): void;
+/** Options accepted by {@link setServerErrors}. */
+type SetServerErrorsOptions = {
+    /** Keep existing field errors instead of clearing them first. Defaults
+     * to `false`: a fresh server response replaces the prior error state. */
+    keepExisting?: boolean;
+};
+/**
+ * Land a server-side error response on the form: each entry becomes the
+ * named field's error(s) with `type: 'server'`, ready for the same
+ * renderError/`useError` channel client-side validation uses. Takes the
+ * flat `Record<string, string | string[]>` shape REST APIs commonly
+ * return (RealWorld: `422 {errors: {email: ['has already been taken']}}`)
+ * without a hand-rolled `Object.entries` + `setError` loop.
+ *
+ * A string value lands as one error, a string array as several (first one
+ * is what `getError`/`error` expose); an empty array clears that field's
+ * errors. By default every existing error is cleared first — a fresh
+ * response describes the current state, not a patch onto stale client
+ * errors; pass `keepExisting: true` to layer instead.
+ * @param form
+ * @param errors field errors keyed by name
+ * @param options
+ */
+declare function setServerErrors(form: Form, errors: Record<string, string | string[]>, options?: SetServerErrorsOptions): void;
+/**
+ * Drop every `type: 'server'` error from the form — the round-trip state
+ * a previous submit landed. {@link handleSubmit} runs this before its
+ * validation round so a retry is judged on the fresh attempt, not on the
+ * server's verdict for the last payload (client errors are untouched:
+ * they describe the current form state). Emits payload-less 'errors' when
+ * anything changed.
+ */
+declare function clearServerErrors(form: Form): void;
+/**
+ * Set field touched state
+ * @param form
+ * @param name
+ */
+/**
+ * @param form
+ */
+declare function hasErrors({ errors }: Form): boolean;
+
+declare function unsetValidatingByPath({ emitter, validating }: Form, path: Path): void;
+declare function setValidatingByPath({ emitter, validating }: Form, path: Path): void;
+/**
+ * Field validator. Returns an error (a string, a FieldError, or an array
+ * mixing both) or undefined when valid; may return a Promise for async
+ * validation.
+ *
+ * The second argument carries the validation context. `meta.signal` is
+ * aborted as soon as the round is superseded — a newer round started, or
+ * the field unregistered — so async validators can cancel their underlying
+ * work (fetch, timers) instead of racing a stale result home. Stale
+ * results are dropped independently by the registration's lock
+ * ({@link registerValidatorByPath}), so validators that ignore the signal
+ * stay correct too. Validators written against the older two-argument
+ * signature keep working.
+ */
+type Validator = (value: any, meta: {
+    form: Form;
+    path: Path;
+    signal: AbortSignal;
+}) => string | FieldError | (string | FieldError)[] | undefined | Promise<string | FieldError | (string | FieldError)[] | undefined>;
+/**
+ * Synchronous pre-validator for {@link registerValidatorByPath}'s `sync`
+ * accessor — declarative `required` rules compiled by `rulesToValidator`
+ * in practice, but any sync-only check works. Runs on every kick, never
+ * debounced: its errors land immediately and, while present,
+ * short-circuit the debounced validator for that kick (the expensive
+ * check never sees a value the gate already rejects). Must be synchronous
+ * — unlike a {@link Validator} it may not return a Promise — and its meta
+ * carries no `signal`: there is nothing to abort in a synchronous check.
+ */
+type SyncValidator = (value: any, meta: {
+    form: Form;
+    path: Path;
+}) => string | FieldError | (string | FieldError)[] | undefined;
+/** Live options for {@link registerValidatorByPath}: read at every kick
+ * through accessors, so callers (React's `useValidate`) can swap the
+ * validator/debounce/sync-gate per render without re-subscribing the
+ * registration mid-flight. */
+type ValidatorRegistration = {
+    /** Current debounced validator (or undefined — a sync-only
+     * registration). */
+    validate: () => Validator | undefined;
+    /** Debounce delay in milliseconds; 0 (default) runs immediately. */
+    debounce: () => number;
+    /** Synchronous pre-validator, run on every kick (never debounced). */
+    sync: () => SyncValidator | undefined;
+    /** Whether the debounced validator still runs when the sync gate
+     * failed — TanStack Form's `asyncAlways`: the gate's errors land
+     * immediately (never debounced), then the validator's own result lands
+     * alongside them (per-source semantics) instead of the gate
+     * short-circuiting the whole kick. Optional — absent means false
+     * (gate failure owns the kick's outcome), so pre-existing
+     * framework-free registrations keep working unchanged. */
+    asyncAlways?: () => boolean;
+};
+/**
+ * Register a field validator's kick at `path` in {@link Form.validators}
+ * — the framework-free machinery behind `useValidate`. Returns a
+ * disposer that drops the registration and cancels any pending debounce
+ * window or in-flight round (its signal aborts and its validating mark
+ * is released).
+ *
+ * Contract of the registered kick (the same contract `trigger` /
+ * `ensureValidate` rely on when they run every entry, and the
+ * user-change gate relies on when it runs the changed path's entry):
+ * - the `sync` gate runs immediately on every kick — never debounced —
+ *   and while it returns errors, the debounced validator is skipped for
+ *   that kick and any pending window or in-flight round is superseded —
+ *   unless `asyncAlways` is set, in which case the validator still runs
+ *   and its result lands alongside the gate's errors (per-source);
+ * - a positive `debounce` merges kicks inside the window: only the last
+ *   one runs the validator, and while the timer is pending the field
+ *   counts as validating so `trigger`/`ensureValidate` wait it out;
+ * - async results land under a lock: a superseded round's outcome —
+ *   rejection included — is dropped, and only the owning round releases
+ *   the validating mark;
+ * - a synchronous throw inside the validator propagates to the caller
+ *   (the validating mark is not left stuck behind it).
+ *
+ * Registering at a path already registered by another mount replaces it
+ * (last-wins, the historical `useValidate` behavior); the disposer drops
+ * its own registration unconditionally.
+ *
+ * @param form
+ * @param path
+ * @param registration live validator/debounce/sync accessors
+ * @return disposer: unregister and cancel pending work
+ */
+declare function registerValidatorByPath(form: Form, path: Path, registration: ValidatorRegistration): () => void;
+/**
+ * Set field error
+ * @param form
+ * @param name
+ * @param error string is normalized to {type: 'custom', message}; a
+ *        FieldError object is stored as-is; an array holds several errors
+ *        (falsy items dropped, strings normalized); undefined clears
+ */
+/** Options accepted by {@link trigger}. `shouldTouch` defaults to `false`;
+ * omitting the options object entirely keeps the plain validate-only
+ * behavior, so the historical two-argument calls are untouched. */
+type TriggerOptions = {
+    /** Mark every path in the triggered scope as touched — even when
+     * validation fails — once the round settles. Mirrors react-hook-form's
+     * trigger `shouldTouch`. Defaults to `false`. */
+    shouldTouch?: boolean;
+    /**
+     * Focus the first errored field in the triggered scope once the round
+     * settles (and only when the round left errors) — react-hook-form's
+     * trigger `shouldFocus` counterpart. Rides the 'focusError' event
+     * channel like a failed submit's auto-focus: only mounted bound fields
+     * react, unmounted ones are silent no-ops. Without `name` the first key
+     * of the errors Map wins (the same rule handleSubmit applies); with
+     * `name` the first errored triggered key does. Defaults to `false`.
+     */
+    shouldFocus?: boolean;
+};
+/**
+ * Trigger field validation.
+ *
+ * Without `name` every registered field validator runs. A single `name` —
+ * dotted string or segments array — runs only that field's validator, and
+ * an array of names runs each one in order. An empty array is a no-op, as
+ * is any name with no registered validator. An array argument counts as
+ * one segments path only when it mixes in numbers (`['items', 0]`); pure
+ * string arrays are name lists, so `['a', 'b']` triggers fields `a` and
+ * `b`, not the nested path `a.b`.
+ *
+ * `options.shouldTouch` marks the triggered scope — the given names, or
+ * every registered field when `name` is omitted — as touched after the
+ * round settles, whether validation passed or failed. The wait/settle
+ * logic is untouched: the marking rides on top of the settled round, so
+ * subscribers observe errors and touched together rather than mid-flight.
+ *
+ * The returned promise waits for the triggered validation to settle —
+ * async validators included — so their errors have already landed in
+ * `form.errors` when it resolves. It never rejects: landing errors is the
+ * expected outcome here, not a failure. Resolves `true` when the triggered
+ * scope is error-free, `false` otherwise. Without `name` the scope is all
+ * fields plus the form-level `validate` result (which runs after field
+ * validators settle, same pipeline as {@link ensureValidate}); with `name`
+ * only those fields' own errors count and form-level `validate` is
+ * skipped (RHF semantics).
+ *
+ * Fire-and-forget callers may ignore the promise: the validator kicks
+ * still happen synchronously, matching the pre-promise behavior.
+ *
+ * @param form
+ * @param name field name(s) to trigger, or all fields when omitted
+ * @param options extra behavior toggles ({@link TriggerOptions}); omitted,
+ *        validation alone runs — no touched marking
+ * @return whether the triggered scope is error-free once validation settles
+ */
+declare function trigger(form: Form, name?: Name | Name[], options?: TriggerOptions): Promise<boolean>;
+/**
+ * Run the form-level `validate` and land its result, honoring the form's
+ * `validateDebounce` option.
+ *
+ * Undebounced (`0`/undefined) the caller's await *is* the validate call —
+ * the long-standing pipeline, unchanged: no validating mark, no round
+ * gating, immediate values snapshot, rejection propagating to the caller.
+ *
+ * Debounced, the kick opens (or restarts — kicks inside the window merge)
+ * a window during which the form counts as validating, so `trigger` /
+ * `ensureValidate` / submit wait the window out exactly like a field's
+ * `validateDebounce` window. When the timer fires, the round reads the
+ * then-current values, supersedes (aborts) any in-flight round, and lands
+ * its result. The returned promise settles once the window group's final
+ * round has landed — rejecting when that round's validate callback threw
+ * or its promise rejected, mirroring the undebounced propagation — so
+ * merged callers all observe the same outcome.
+ *
+ * Only called under `if (form.validate)`. Public: the form-level-only
+ * round (field validators excluded) — `useForm`'s `validateOnMount` run
+ * and cross-cutting re-checks use it; `trigger`/`ensureValidate` compose
+ * it after the field validators settle.
+ */
+declare function runFormValidate(form: Form): Promise<void>;
+/**
+ * Form-level twin of the gated validator kick in `useField`'s onChange:
+ * re-run the form-level `validate` after a user change to a field listed
+ * in `validateDeps`. Called from the field's own change pipeline (typing
+ * and `changeValue` alike — both route through the mounted field's
+ * onChange), so programmatic `setValue` writes do not re-run it, exactly
+ * like they do not re-run field validators.
+ *
+ * The gate mirrors the per-field matrix with the *changed field's*
+ * effective `mode` (a per-field override governs when its changes may
+ * fire validation) and the form-level `reValidateMode` against the last
+ * round's error footprint ({@link hasFormValidateErrors} — field
+ * validators' errors never arm this kick):
+ * - `mode` `'onChange'`/`'all'` — every dep change re-runs;
+ * - `mode` `'onTouched'` — dep changes re-run once the field was touched;
+ * - otherwise the re-run waits for `reValidateMode: 'onChange'` (the
+ *   default) while the last round's error is still live — the
+ *   submit-then-fix flow: the mismatch lands on submit, editing the
+ *   dependency re-runs the validate and clears it.
+ * `reValidateMode: 'onBlur'`/`'onSubmit'` never re-run on a change (a
+ * change is not a blur; submit re-runs are the submit pipeline's job).
+ *
+ * The kick is fire-and-forget: async round rejections are swallowed
+ * (nothing in an event handler can await them), while a synchronous
+ * throw inside the validate callback propagates to the caller exactly
+ * like a field validator's does.
+ *
+ * A no-op unless the form set `validateDeps` listing `path` — forms
+ * without the option pay one property check here.
+ */
+declare function revalidateFormOnChange(form: Form, path: Path, mode: ValidationMode): void;
+/** Register one field's validateDeps declaration: `key` re-validates when
+ * any path in `depKeys` takes a user change. Idempotent per (key, dep)
+ * pair, so StrictMode's double effect is harmless. */
+declare function registerFieldValidateDeps(form: Form, key: string, depKeys: string[]): void;
+/** Drop one field's validateDeps registration ({@link
+ * registerFieldValidateDeps}). Entries nobody lists anymore are removed so
+ * the registry never outlives its fields. */
+declare function unregisterFieldValidateDeps(form: Form, key: string, depKeys: string[]): void;
+/**
+ * Field-level twin of {@link revalidateFormOnChange}: after a user change
+ * to `path`, re-run every field validator that declared `path` in its
+ * `validateDeps` (useField option). Same channel, same gate: the kick
+ * rides the changed field's own onChange pipeline (typing and
+ * `changeValue` alike), so programmatic `setValue` writes never fire it —
+ * exactly like field validators and the form-level `validateDeps`.
+ *
+ * The gate mirrors the form-level matrix with the *changed field's*
+ * effective `mode` and the form-level `reValidateMode` against each
+ * dependent's live error:
+ * - `mode` `'onChange'`/`'all'` — every dep change re-runs the dependent;
+ * - `mode` `'onTouched'` — once the changed field was touched;
+ * - otherwise the re-run waits for `reValidateMode: 'onChange'` (the
+ *   default) while the dependent still shows an error — the
+ *   submit-then-fix flow: the mismatch lands on submit, editing the
+ *   dependency re-validates the dependent and a passing round clears it
+ *   (a field validator owns its whole key, so the re-run's result
+ *   replaces whatever the previous round wrote — the field-level shape
+ *   of the form-level footprint reclaim).
+ *
+ * The kick is an ordinary validator kick: the dependent's own
+ * `validateDebounce` window applies, and a synchronous throw inside its
+ * validate propagates to the caller like any field validator's would.
+ *
+ * A no-op unless some field declared `path` as a dep — forms without any
+ * field-level `validateDeps` pay one property check here.
+ */
+declare function revalidateDependentsOnChange(form: Form, path: Path, mode: ValidationMode): void;
+/** The Error {@link ensureValidate} rejects with: `message` is the first
+ * error's display text ({@link getFirstError}) — the long-standing shape
+ * — and `.errors` carries the complete flattened error list ({@link
+ * getErrors}: `{path, type, message}` entries, dotted display paths) so
+ * catchers can branch on types and locate fields without re-reading the
+ * form. */
+type FormValidationError = Error & {
+    errors: FieldErrorEntry[];
+};
+/**
+ * Validate and throw if any field error.
+ * @param form
+ * @return resolve if no error; reject and stop validate if has an error
+ */
+declare function ensureValidate(form: Form): Promise<void>;
+/**
+ * Validate and return if any field error.
+ * @param form
+ * @return error message string or void
+ */
+declare function validate(form: Form): Promise<void | string>;
+
+/** A field error: `type` identifies the error kind ('custom' for plain
+ * string errors), `message` is the display text. */
+type FieldError = {
+    type: string;
+    message: string;
+};
+/** A flattened entry from {@link getErrors}. */
+type FieldErrorEntry = {
+    path: string;
+    type: string;
+    message: string;
+};
+/** When a field is validated:
+ * - `'onSubmit'` (default): only on submit
+ * - `'onBlur'`: when the field loses focus
+ * - `'onChange'`: on every change
+ * - `'onTouched'`: on first blur, then on every change
+ * - `'all'`: on both change and blur
+ */
+type ValidationMode = 'onSubmit' | 'onBlur' | 'onChange' | 'onTouched' | 'all';
+/** When a field is re-validated after it already has an error:
+ * - `'onChange'` (default): on every change
+ * - `'onBlur'`: when the field loses focus
+ * - `'onSubmit'`: only on submit (no live re-validation)
+ */
+type ReValidateMode = 'onChange' | 'onBlur' | 'onSubmit';
+/** When the form-level {@link Options.validate} re-runs outside
+ * submit/`trigger`/`validateOnMount`:
+ * - `'onSubmit'` (default): only on submit/trigger — cross-field linkage
+ *   goes through {@link Options.validateDeps} instead
+ * - `'onChange'`: every user change to a bound field re-runs it
+ * - `'onBlur'`: every user blur of a bound field re-runs it
+ *
+ * TanStack Form's `validators.onChange`/`validators.onBlur` counterpart:
+ * a cadence declaration instead of enumerating deps. The re-run rides the
+ * changed field's own user-change pipeline (typing and `changeValue`
+ * alike, never programmatic `setValue`), honors {@link
+ * Options.validateDebounce}, and reuses the round-scoped error footprint —
+ * a passing re-run clears what the previous round wrote.
+ */
+type FormValidateMode = 'onSubmit' | 'onChange' | 'onBlur';
+/**
+ * Options accepted by {@link Form.register} — the non-hook binding for
+ * uncontrolled fields (react-hook-form's `register` contract: the bound
+ * element never re-renders; the store carries every write).
+ */
+type RegisterOptions = {
+    /**
+     * Field-level validation mode for this binding (see {@link
+     * ValidationMode}): typing gates on it exactly like a mounted
+     * `useField`. Defaults to the form's `mode`.
+     */
+    mode?: ValidationMode;
+    /**
+     * Unmount behavior: `true` (the default, this library's historical
+     * default) tombstones the path when the element unmounts, `false` keeps
+     * the value. Falls back to the form-level
+     * `createForm({shouldUnregister})` when omitted.
+     */
+    shouldUnregister?: boolean;
+    /**
+     * DOM event → value extractor for the returned `onChange`. Defaults to
+     * the element's own protocol: `target.files` for file inputs,
+     * `target.checked` for checkboxes, `target.valueAsNumber` /
+     * `target.valueAsDate` under those flags, `target.value` otherwise —
+     * the same extraction `<Field>` performs.
+     */
+    eventToValue?: (e: any) => any;
+    /** Store `e.target.valueAsNumber` instead of the string value
+     * (`<input type="number">`, RHF's `register({valueAsNumber})`). An
+     * explicit `eventToValue` takes precedence. */
+    valueAsNumber?: boolean;
+    /** Store `e.target.valueAsDate` instead of the string value (RHF's
+     * `register({valueAsDate})`). An explicit `eventToValue` takes
+     * precedence; combining with `valueAsNumber` is a TypeError. */
+    valueAsDate?: boolean;
+    /**
+     * Declarative rules for this binding — the same {@link FieldRules}
+     * `useField`/`<Field>` take (`required` runs as the synchronous gate,
+     * `validate` callbacks included). Wired through the framework-free
+     * `registerValidatorByPath`, so `trigger`/submit/`mode` gating see it
+     * exactly like a hook-registered validator. `validateDebounce` is
+     * fixed at 0 — the rules run immediately on every kick.
+     */
+    rules?: FieldRules;
+};
+/**
+ * What {@link Form.register} returns: spread these props onto an
+ * uncontrolled DOM element (`<input {...form.register('name')} />`).
+ * The bound element never re-renders — read live state through
+ * `useValue`/`useError`/`getValues`, exactly like react-hook-form's
+ * `register` contract. `name` is the store's path key; `onChange` writes
+ * the extracted value through the gated user-change pipeline; `ref`
+ * attaches the element (seeds its initial DOM content into the store,
+ * wires the 'focusError' channel and bulk-reset DOM sync) and detaches it
+ * on unmount (tombstone unless `shouldUnregister: false`).
+ */
+type RegisterProps = {
+    name: string;
+    onChange: (e: any) => void;
+    onBlur: () => void;
+    ref: (el: any) => void;
+};
+/** Structured form-level validate result: `errors` uses the same nested
+ * shape a plain error record uses, `values` is the schema's parsed output
+ * (coerce/transform results included). Either side may be omitted.
+ *
+ * The brand constant itself lives in the errors module (the leaf module of
+ * the core dependency graph — every consumer imports it from there) and is
+ * re-exported below with `export *`. */
+type ValidationOutcome<T> = {
+    [VALIDATION_OUTCOME]: true;
+    errors?: Record<string, any>;
+    values?: T;
+};
+/** What a form-level validate function may return: a plain nested error
+ * record (flattened into field errors — the long-standing shape), or a
+ * branded {@link ValidationOutcome} whose `values` become the form's
+ * parsedValues baseline. */
+type ValidateResult<T> = Record<string, any> | ValidationOutcome<T> | Promise<Record<string, any> | ValidationOutcome<T>>;
+/** Context passed to a form-level `validate` function's second argument.
+ * `signal` aborts as soon as the round is superseded — a newer round
+ * started (which only happens under a positive `validateDebounce`, where
+ * kicks merge into windows) — so async validators can cancel their
+ * underlying work instead of racing a stale result home. Stale results
+ * are dropped independently by the round gate, so validators that ignore
+ * the signal stay correct too; the same contract field-level validators
+ * get through their own `meta`. */
+type FormValidateMeta<T extends Record<string, any> = any> = {
+    form: Form<T>;
+    signal: AbortSignal;
+};
+/** Form-level validator: receives all values (plus {@link
+ * FormValidateMeta} as an optional second argument) and returns a
+ * {@link ValidateResult} — sync or async — or `undefined`/nothing when
+ * valid (the runtime skips falsy results, so implicit-return callbacks
+ * type-check). */
+type FormValidateFn<T extends Record<string, any> = any> = (values: T, meta: FormValidateMeta<T>) => ValidateResult<T> | undefined;
+/**
+ * The emitter event table for {@link Form.emitter}: each event's payload
+ * tuple. Path-carrying events declare an optional single `Path` payload —
+ * emit sites send it for single-field mutations and omit it for bulk
+ * payload-less broadcasts (reset, setInitialValues, clear-all), both of
+ * which subscribers handle. `focusError` carries the target's path key
+ * plus optional {@link SetFocusOptions}.
+ */
+type FormEvents = ['change', [path?: Path]] | ['errors', [path?: Path]] | ['touched', [path?: Path]] | ['validating', [path?: Path]] | ['submitting', []] | ['submitCount', []] | ['submitSuccessful', []] | ['reset', []] | ['disabled', [path?: Path]] | ['status', []] | ['loading', []] | ['focusError', [key: string, options?: SetFocusOptions]];
+type Form<T extends Record<string, any> = any> = {
+    emitter: EventEmitter<FormEvents>;
+    mode: ValidationMode;
+    reValidateMode: ReValidateMode;
+    initialValues: T;
+    values: Map<string, any>;
+    /** Tombstones of unregistered field paths (JSON path keys): reading or
+     * merging values must not fall back to initialValues for these paths. */
+    deleted: Set<string>;
+    /** Every error registered for a field, as a non-empty array (the
+     * write-side {@link setErrorByPath} normalizes to this invariant, so
+     * readers never need to guard against an empty list). Readers wanting
+     * the display error take the first entry ({@link getError}); readers
+     * wanting all of them use {@link getFieldErrors}. */
+    errors: Map<string, FieldError[]>;
+    touched: Set<string>;
+    /** Per-field validation kicks, registered by {@link
+     * registerValidatorByPath} (`useValidate` is the React-side
+     * registration): each is the field's debounce/lock-aware kick —
+     * invoking it validates the field's current value. `trigger` /
+     * `ensureValidate` run every entry; the user-change gate ({@link
+     * userChangeByPath}) runs the entry at the changed path. */
+    validators: Map<string, () => void>;
+    validating: Set<string>;
+    /** Parsed values from the last successful schema validation: the
+     * schema's complete output tree (coerced/transformed values included).
+     * Sits between initialValues and the values Map in {@link getValues}
+     * until `reset`/`setInitialValues` clears it. Never affects dirty
+     * state — that compares live edits against initialValues only. */
+    parsedValues: T | undefined;
+    /** Form-level validator, seeded from {@link Options.validate}. May
+     * receive a second {@link FormValidateMeta} argument. */
+    validate?: FormValidateFn<T>;
+    /** Delay in milliseconds before the form-level `validate` runs; seeded
+     * from {@link Options.validateDebounce} and fixed at create time. */
+    validateDebounce?: number;
+    /** Path keys (JSON-stringified segments) of the fields whose user
+     * changes re-run the form-level `validate`; normalized from {@link
+     * Options.validateDeps} at create time and fixed thereafter. */
+    validateDeps?: ReadonlySet<string>;
+    /** When the form-level `validate` re-runs outside submit/trigger —
+     * the cadence declared by {@link Options.validateMode}, seeded at
+     * create time and fixed thereafter ('onSubmit' by default; with
+     * 'onChange'/'onBlur' every user change/blur to a bound field re-runs
+     * it, no dep list required). */
+    validateMode: FormValidateMode;
+    isSubmitting: boolean;
+    /** Whether a submit has been attempted — set by `handleSubmit` on every
+     * attempt (validation outcome aside), cleared by `reset`.
+     * `useFormState().isSubmitted` reads it (react-hook-form's
+     * `formState.isSubmitted` semantics). */
+    isSubmitted: boolean;
+    submitCount: number;
+    isSubmitSuccessful: boolean | undefined;
+    /** True while an async {@link Options.initialValues} source (a Promise,
+     * or a thunk returning one) is still pending — the form starts empty
+     * and the resolved values become the baseline via setInitialValues when
+     * it lands. Flips through the payload-less 'loading' event
+     * (`useIsLoading` / `useFormState().isLoading`). */
+    isLoading: boolean;
+    /** Form-level default for a bound field's unmount behavior, seeded from
+     * {@link Options.shouldUnregister}: `true` (the default) tombstones an
+     * unmounted field, `false` keeps its value (react-hook-form's
+     * `shouldUnregister` semantics). A field's own `shouldUnregister` option
+     * overrides this. */
+    shouldUnregister?: boolean;
+    /** Form-level disabled flag, OR-ed into every bound field's `disabled`
+     * (form flag || the field's own option). Seeded from
+     * {@link Options}.disabled at create time and toggled at runtime with
+     * {@link setDisabled}, which emits a payload-less 'disabled' event so
+     * subscribed fields re-render. */
+    disabled: boolean;
+    /** Form-level default for mount validation, seeded from
+     * {@link Options.validateOnMount}: `true` makes every mounted field
+     * with a validator kick once after mount (deferred until an async
+     * {@link Options.initialValues} source lands), and makes `useForm` run
+     * the form-level `validate` once. A field's own `validateOnMount`
+     * option overrides this flag in either direction. */
+    validateOnMount: boolean;
+    /** Form-level default for {@link UseValidateOptions.asyncAlways}:
+     * whether a field's debounced validator still runs when its `required`
+     * gate failed. A field's own `asyncAlways` option overrides this flag
+     * in either direction. Seeded from {@link Options.asyncAlways}. */
+    asyncAlways: boolean;
+    /**
+     * Whether native constraint validation gates submission (the submitted
+     * element's checkValidity, skipped for targets without it — React
+     * Native, toolbar buttons) and skips a bound `<Field>`'s custom
+     * validators on a native-failing kick. Seeded from
+     * {@link Options.shouldUseNativeValidation} — default `true`; a submit
+     * may override per attempt via
+     * {@link HandleSubmitOptions.shouldUseNativeValidation}.
+     */
+    shouldUseNativeValidation: boolean;
+    /**
+     * User-owned metadata slot for non-field state — session flags, server
+     * backfill that belongs to no field, step indices (Formik's `status`
+     * role). Written with {@link setStatus}, which emits the payload-less
+     * 'status' event; read directly or reactively through {@link useStatus}.
+     * Starts `undefined`.
+     */
+    status: any;
+    /**
+     * Non-hook field binding — react-hook-form's `register` contract:
+     * spread the returned props onto an uncontrolled DOM element
+     * (`<input {...form.register('name')} />`) and the element never
+     * re-renders, while the store carries every write and `trigger`/submit
+     * validate it. Seeding, the 'focusError' channel, bulk-reset DOM sync
+     * and unmount tombstoning ride the `ref` callback's attach/detach —
+     * no React state involved, so `register` works anywhere (dynamic
+     * lists, conditional fields, non-React adapters). See {@link
+     * RegisterOptions} / {@link RegisterProps}.
+     */
+    register: (name: Name, options?: RegisterOptions) => RegisterProps;
+};
+type Options<T extends Record<string, any> = any> = {
+    /**
+     * The values baseline. Sync objects seed immediately (SSR renders
+     * them). Async sources — a Promise, or a thunk returning a value or
+     * Promise (react-hook-form's async `defaultValues` shape) — start the
+     * form empty with `isLoading: true` and land the resolved values as
+     * the baseline via setInitialValues once they resolve: value
+     * subscribers re-sync, dirty/touched state starts clean, and a later
+     * `reset()` returns to the resolved baseline. A rejected source flips
+     * isLoading back to false, keeps the form empty, and logs the error in
+     * DEV — attach a `.catch` on the source itself to handle it. The thunk
+     * runs at create time: keep its identity stable (module scope or
+     * useMemo) when passing it inline, and note StrictMode double-invokes
+     * it in development, like every render-phase call.
+     */
+    initialValues?: T | Promise<T> | (() => T | Promise<T>);
+    /** When fields are validated. Defaults to `'onSubmit'`. See
+     * {@link ValidationMode}. */
+    mode?: ValidationMode;
+    /** When a field is re-validated after it already has an error — it only
+     * takes effect once the field has an error. Defaults to `'onChange'`. See
+     * {@link ReValidateMode}. */
+    reValidateMode?: ReValidateMode;
+    /**
+     * Form-level validator. Returns a record of errors keyed by field path;
+     * nested objects are flattened ('a.b' style) and array values contribute
+     * every non-empty string they hold as separate errors (zod `flatten()`
+     * formErrors style). Schema adapters instead return a branded
+     * {@link ValidationOutcome}: `errors` flattens the same way, `values`
+     * (the schema's parsed output) becomes the form's parsedValues baseline
+     * that {@link getValues} layers over initialValues.
+     *
+     * Alternatively pass a Standard Schema v1 object directly (zod
+     * v3.24+/v4, valibot v1, arktype, …) — it is wrapped into a form-level
+     * validator automatically, no resolver import needed, and `TValues`
+     * infers from the schema's output type:
+     * `createForm({validate: schema})` → `Form<InferSchemaValues<typeof
+     * schema>>`.
+     */
+    validate?: FormValidateFn<T> | StandardSchemaV1<unknown, T>;
+    /**
+     * Milliseconds to debounce the form-level `validate`: kicks from
+     * `trigger`/`ensureValidate`/submit inside the window merge into one
+     * run, and while the timer is pending the form counts as validating,
+     * so `trigger` and submit wait the window out — the same contract the
+     * per-field `validateDebounce` gives field validators. The merged run
+     * reads the values current when its timer fires. Defaults to `0`
+     * (validate runs immediately, exactly as before this option existed).
+     */
+    validateDebounce?: number;
+    /** Fields whose user changes re-run the form-level `validate` — the
+     * cross-field dependency list (password-confirm mismatch and friends).
+     * Each entry is a field path ('password', 'user.email', 'items.0.qty');
+     * a user change to a listed field re-runs the form-level `validate`
+     * under the same mode/`reValidateMode` gating the field's own
+     * validator gets. Omit it and the form-level `validate` only runs on
+     * `trigger`/submit, exactly as before this option existed.
+     *
+     * Opting in also changes what a re-run may clear: each round first
+     * drops the errors the previous round wrote (paths it flattened onto),
+     * so a dep change that fixes the cross-field error makes it disappear.
+     * Errors the round never wrote — field validators', `setServerErrors`,
+     * manual `setError` — are never touched. TanStack Form's counterpart is
+     * `onChangeListenTo` (v1) / validator `triggers` (v2 alpha). */
+    validateDeps?: FieldPath<T>[];
+    /**
+     * When the form-level `validate` re-runs outside submit/`trigger`/
+     * `validateOnMount` — a cadence declaration instead of enumerating
+     * {@link Options.validateDeps}. `'onSubmit'` (the default) keeps the
+     * historical behavior (submit/trigger only, deps for cross-field
+     * linkage). `'onChange'` re-runs the form-level validate on every user
+     * change to a bound field; `'onBlur'` on every user blur. The re-run
+     * rides the changed field's own user-change pipeline (typing and
+     * `changeValue` alike, never programmatic `setValue`), honors
+     * {@link Options.validateDebounce}, and clears what the previous round
+     * wrote — TanStack Form's `validators.onChange`/`validators.onBlur`
+     * counterpart. See {@link FormValidateMode}.
+     */
+    validateMode?: FormValidateMode;
+    /**
+     * Form-level default for a bound field's unmount behavior. `true` (the
+     * default) tombstones an unmounted field — it drops out of
+     * `getValues()` instead of reviving its initial value (this library's
+     * historical default); `false` keeps the value, matching
+     * react-hook-form's `shouldUnregister`. A field's own
+     * `useField({shouldUnregister})` option overrides the form-level flag
+     * in either direction.
+     */
+    shouldUnregister?: boolean;
+    /** Start the form with every bound field disabled — the flag bound
+     * fields OR with their own `disabled` option (a field cannot opt out
+     * of a disabled form). Toggle later with {@link setDisabled}.
+     * Defaults to `false`. */
+    disabled?: boolean;
+    /**
+     * Form-level default for field validation's `asyncAlways`: when true,
+     * a field whose `required` gate failed still runs its debounced
+     * validator (the gate's errors land immediately, the validator's own
+     * result lands alongside them per-source). TanStack Form's
+     * `asyncAlways` counterpart. A field's own
+     * `useField({asyncAlways})` option overrides the form-level flag in
+     * either direction. Defaults to `false`.
+     */
+    asyncAlways?: boolean;
+    /**
+     * Whether native constraint validation gates submission and skips a
+     * bound `<Field>`'s custom validators when its native constraints fail
+     * that kick (react-hook-form's `shouldUseNativeValidation`): pass
+     * `false` for forms where custom validators are the only source of
+     * truth — the browser's checkValidity/reportValidity gate (and the
+     * per-kick native gate in `<Field>`) stop running, while declarative
+     * `rules` keep producing store-side errors and native constraint
+     * attributes keep rendering for a11y. Defaults to `true`. Fixed at
+     * create time; a single submit may override it through
+     * {@link HandleSubmitOptions.shouldUseNativeValidation}.
+     */
+    shouldUseNativeValidation?: boolean;
+    /**
+     * Validate on mount: `true` makes every mounted field with a validator
+     * (declarative `rules` or a `validate` callback) run it once after
+     * mount, instead of waiting for the first submit/change — errors show
+     * immediately for an untouched form (Formik's `validateOnMount` /
+     * TanStack Form's per-field `validateOnMount`). The form-level
+     * `validate` also runs once after mount. Mount kicks are deferred
+     * while an async `initialValues` source is still pending: validating
+     * the empty shell would land spurious required errors, so the kicks
+     * fire after the resolved baseline lands instead. A field's own
+     * `useField({validateOnMount})` option overrides the form-level flag
+     * in either direction. Defaults to `false`.
+     */
+    validateOnMount?: boolean;
+};
+/**
+ * Create form instance
+ * @param options
+ * @return form instance
+ */
+declare function create<T extends Record<string, any> = any>(options?: Options<T>): Form<T>;
+
+export { registerFieldValidateDeps as $, clearErrors as C, clearServerErrors as E, create as G, dottedKeyToFieldPath as H, ensureValidate as J, fieldPathToDottedKey as K, getError as L, getErrorByPath as M, getErrors as Q, getErrorsRecord as U, getErrorsTree as W, getFieldErrors as X, getFieldErrorsByPath as Y, getFirstError as Z, hasErrors as _, registerValidatorByPath as a0, revalidateDependentsOnChange as a1, revalidateFormOnChange as a2, runFormValidate as a3, setError as a4, setErrorByPath as a5, setFocus as a6, setServerErrors as a7, setValidatingByPath as a8, trigger as a9, unregisterFieldValidateDeps as aa, unsetValidatingByPath as ab, validate as ac, hasStandardProps as ae, schemaToFormValidator as af, schemaToFieldValidator as ag, VALIDATION_OUTCOME as b, FORM_ERROR as n };
+export type { ArrayItemOf as A, ValidatorRegistration as B, DottedPath as D, Form as F, InferSchemaValues as I, Name as N, Options as O, PathSegments as P, RegisterOptions as R, StandardSchemaV1 as S, TriggerOptions as T, Validator as V, FieldErrorEntry as a, StandardSchemaIssue as ad, ValidationOutcome as c, FieldPath as d, Path as e, FieldError as f, PathValueOf as g, ValidationMode as h, RegisterProps as i, FieldRules as j, FieldErrors as k, FieldErrorsTree as l, FormEvents as m, FormValidateFn as o, FormValidateMeta as p, FormValidateMode as q, FormValidationError as r, OpaqueTypes as s, PathValue as t, ReValidateMode as u, SetErrorOptions as v, SetFocusOptions as w, SetServerErrorsOptions as x, SyncValidator as y, ValidateResult as z };