react-f0rm 1.1.1 → 1.3.0

package/dist/index.d.ts

@@ -1,9 +1,502 @@
-import { a as FieldPath, N as Name, F as Form$1, V as ValidationMode, P as PathValueOf, b as FieldError, c as Path, O as Options } from './form-BiDaJLjD.js';
-export { d as FieldErrorEntry, e as FieldState, f as FormValidateFn, g as FormValidateMeta, h as FormValidationError, H as HandleSubmitOptions, i as PathValue, R as ReValidateMode, j as ResetFieldOptions, k as ResetOptions, S as SetFieldOptions, l as SetFocusOptions, m as SetServerErrorsOptions, n as VALIDATION_OUTCOME, o as ValidateResult, p as ValidationOutcome, q as changeValue, r as changeValueByPath, s as clearErrors, t as createForm, u as emitChangeByPath, v as ensureValidate, w as getDirtyFields, x as getError, y as getErrorByPath, z as getErrors, A as getFieldErrors, B as getFieldErrorsByPath, C as getFieldState, D as getFirstError, E as getTouchedFields, G as getValue, I as getValueByPath, J as getValues, K as handleSubmit, L as hasErrors, M as hasTouched, Q as hasTouchedByPath, T as incrementSubmitCount, U as isDirty, W as isTouched, X as registerFieldValidateDeps, Y as removeField, Z as removeFieldByPath, _ as reset, $ as resetField, a0 as revalidateDependentsOnChange, a1 as revalidateFormOnChange, a2 as seedValueByPath, a3 as setDisabled, a4 as setError, a5 as setErrorByPath, a6 as setFocus, a7 as setInitialValues, a8 as setIsSubmitting, a9 as setServerErrors, aa as setSubmitSuccessful, ab as setTouched, ac as setTouchedByPath, ad as setValidatingByPath, ae as setValue, af as setValueByPath, ag as trigger, ah as unregisterFieldValidateDeps, ai as unsetValidatingByPath, aj as validate } from './form-BiDaJLjD.js';
-import { V as Validator } from './validate-2XUilILy.js';
+import { a as FieldError, F as Form$1, P as Path, b as FieldPath, c as PathSegments, d as PathValueOf, N as Name, V as ValidationMode, e as FieldErrorEntry, O as Options, f as FormEvents } from './form-CeKSBs31.js';
+export { g as FORM_ERROR, h as FormValidateFn, i as FormValidateMeta, j as PathValue, R as ReValidateMode, S as SetErrorOptions, k as SetFocusOptions, l as SetServerErrorsOptions, m as VALIDATION_OUTCOME, n as ValidateResult, o as ValidationOutcome, p as clearErrors, q as createForm, r as getError, s as getErrorByPath, t as getErrors, u as getFieldErrors, v as getFieldErrorsByPath, w as getFirstError, x as hasErrors, y as setError, z as setErrorByPath, A as setFocus, B as setServerErrors } from './form-CeKSBs31.js';
+import { EventEmitter } from '@for-fun/event-emitter';
+export { EventEmitter } from '@for-fun/event-emitter';
 import * as React from 'react';
 import { ReactNode } from 'react';
-import { EventEmitter } from '@for-fun/event-emitter';
+import { S as SyncValidator, V as Validator } from './validate-nksgv1pR.js';
+export { F as FormValidationError, T as TriggerOptions, a as ValidatorRegistration, e as ensureValidate, r as registerFieldValidateDeps, b as registerValidatorByPath, c as revalidateDependentsOnChange, d as revalidateFormOnChange, f as runFormValidate, s as setValidatingByPath, t as trigger, u as unregisterFieldValidateDeps, g as unsetValidatingByPath, v as validate } from './validate-nksgv1pR.js';
+
+/**
+ * Get form values: the values Map layered over parsedValues (when a schema
+ * validation produced them) layered over initialValues.
+ *
+ * Merged with copy-on-write ownership tracking ({@link setOwned}): every
+ * distinct container on a written path is allocated once and shared by all
+ * paths through it, instead of re-copying the whole branch for every key.
+ * One owned set spans the whole merge, so containers borrowed from the
+ * parsedValues tree are copied before mutation exactly like initialValues
+ * ones. The result is a freshly merged tree per mutation, with untouched
+ * branches sharing references with the baseline exactly like chained
+ * `set` did.
+ *
+ * Memoized per form like {@link getDirtyFields}: every value write bumps a
+ * `version` counter ({@link bumpValuesVersion}) while reads reset it, so
+ * consecutive reads hand back the same reference (submit, changeValue and
+ * form-level validate all read the whole tree, often several times per
+ * interaction). Treat the result as read-only — the next read after a
+ * write returns a fresh tree, but between writes the cached one is shared
+ * with every other reader.
+ *
+ * parsedValues is the schema's complete output tree: once validation
+ * succeeds it replaces the initialValues baseline (fields the schema
+ * dropped disappear), while live edits in the values Map still win over
+ * both. It never affects dirty state — {@link isDirty} and
+ * {@link getDirtyFields} compare live edits against initialValues only,
+ * because parsing is not a user edit.
+ *
+ * @param form
+ */
+declare function getValues<T extends Record<string, any> = any>(form: Form$1<T>): T;
+/**
+ * Get field value
+ * @param form
+ * @param name
+ */
+declare function getValue<T extends Record<string, any> = any, P extends FieldPath<T> | PathSegments = FieldPath<T> | PathSegments>(form: Form$1<T>, name: P): PathValueOf<T, P>;
+/**
+ * Get field value by path
+ * @param form
+ * @param path
+ */
+declare function getValueByPath({ initialValues, parsedValues, values, deleted }: Form$1, path: Path): any;
+/** Options accepted by {@link setValue} / {@link setValueByPath} / {@link
+ * changeValue} / {@link changeValueByPath}. `shouldValidate`/`shouldTouch`
+ * default to `false`; omitting the options object entirely keeps the plain
+ * set-value behavior (no validation, no touched marking, dirty stays
+ * derived). */
+type SetFieldOptions = {
+    /** Run the field's registered validator (if any) after the value lands,
+     * same as triggering that single field. Defaults to `false`. */
+    shouldValidate?: boolean;
+    /** Mark the field as touched. Defaults to `false`. */
+    shouldTouch?: boolean;
+    /** Land the value as a commit instead of an edit: the value becomes the
+     * field's dirty-comparison baseline, so `getDirtyFields`/`isDirty`/
+     * `getFieldState().isDirty` read the field as clean, and a later write
+     * dirties it only by differing from the new baseline. `true` (or
+     * omitting the flag) keeps the default derived behavior — dirty while
+     * the live value differs from initialValues. */
+    shouldDirty?: boolean;
+};
+/**
+ * Set field value. The value may also be an updater function receiving
+ * the field's current value and returning the next one (TanStack Form's
+ * `setFieldValue` contract) — handy for increments and array transforms:
+ * `setValue(form, 'count', c => c + 1)`. The tradeoff: a function can
+ * never itself be stored as a field value through this function.
+ * @param form
+ * @param name
+ * @param value
+ * @param options
+ */
+declare function setValue<T extends Record<string, any> = any, P extends FieldPath<T> | PathSegments = FieldPath<T> | PathSegments>(form: Form$1<T>, name: P, value: PathValueOf<T, P> | ((prev: PathValueOf<T, P>) => PathValueOf<T, P>), options?: SetFieldOptions): void;
+/**
+ * Set field value. The value may also be an updater function receiving
+ * the field's current value and returning the next one (TanStack Form's
+ * `setFieldValue` contract) — note that a function can therefore never
+ * itself be stored as a field value through this function.
+ * @param form
+ * @param path
+ * @param value
+ * @param options
+ */
+declare function setValueByPath(form: Form$1, path: Path, value: any | ((prev: any) => any), options?: SetFieldOptions): void;
+/**
+ * The write of {@link setValueByPath} minus the `'change'` emit: the
+ * render-time {@link useField} `initialValue` seed. The field's first
+ * paint (SSR included — effects never run on the server) must already
+ * carry the value, so the write happens during render where emitting is
+ * illegal; the seeding field announces it from its post-commit effect
+ * through {@link emitChangeByPath} instead.
+ *
+ * Everything else matches a plain write: descendant keys of the seeded
+ * path are pruned, the branch's tombstones and committed baselines are
+ * revived/dropped, and both memo caches are invalidated. Like the effect
+ * seed it replaces, the caller guards it to paths with no value yet.
+ */
+declare function seedValueByPath(form: Form$1, path: Path, value: any): void;
+/** Announce a {@link seedValueByPath} that happened during render: the
+ * payload-carrying `'change'` emit {@link setValueByPath} would have
+ * fired, split out so it can run post-commit where emitting is safe.
+ * Subscribers that rendered after the seed re-read an unchanged snapshot
+ * and bail; subscribers from earlier commits resync. */
+declare function emitChangeByPath({ emitter }: Form$1, path: Path): void;
+/** Per-form registry of mounted fields' validation-mode overrides: path
+ * key -> the field's `mode` option (undefined = follow {@link Form.mode})
+ * plus an owner token so competing mounts at one path clean up safely.
+ * Presence of an entry is the "a field is mounted at this path" signal
+ * that routes {@link changeValueByPath} into the gated user-change
+ * pipeline ({@link userChangeByPath}). Held in a WeakMap so the Form
+ * shape carries only plain state fields. */
+/** 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. */
+type FieldState<T = any> = {
+    value: T;
+    error: FieldError | undefined;
+    errors: FieldError[];
+    isDirty: boolean;
+    isTouched: boolean;
+    isValidating: boolean;
+};
+/**
+ * Get one field's aggregated state: the layered value ({@link getValue}),
+ * the first error ({@link getError}) and every error ({@link
+ * getFieldErrors}), dirtiness, the touched flag, and whether a validator
+ * is in flight. `isDirty` applies the same per-field rule as {@link
+ * getDirtyFields}: a live value exists and differs from initialValues at
+ * that path (parsedValues never counts — parsing is not an edit).
+ *
+ * @param form
+ * @param name
+ */
+declare function getFieldState<T extends Record<string, any> = any, P extends FieldPath<T> | PathSegments = FieldPath<T> | PathSegments>(form: Form$1<T>, name: P): FieldState<PathValueOf<T, P>>;
+/**
+ * Remove a field: by default its live value drops out of reads and
+ * `getValues()` (the path is tombstoned, so it never falls back to
+ * initialValues), its dirty baseline, touched flag and errors are cleared.
+ * The keep-flags preserve slices of that state instead.
+ *
+ * @param form
+ * @param name
+ */
+/**
+ * Options accepted by {@link removeField}. All flags default to `false` —
+ * the historical remove semantics (value dropped, path tombstoned, dirty
+ * baseline/touched/errors cleared). Names mirror react-hook-form's
+ * `unregister` options to ease migration; RHF's `shouldValidate` and
+ * `keepDefaultValue` have no counterparts (removal never validates, and
+ * the tombstone is exactly the "do not revive from initialValues" choice).
+ */
+type RemoveFieldOptions = {
+    /** Keep the field's live value and dirty baseline instead of
+     * tombstoning: reads and `getValues()` keep returning the value, submit
+     * includes it, and dirtiness against initialValues is preserved. */
+    keepValue?: boolean;
+    /** Keep the field's dirty baseline. Implies `keepValue` — a removed
+     * value has nothing to be dirty about. */
+    keepDirty?: boolean;
+    /** Keep the field's touched flag instead of clearing it. */
+    keepTouched?: boolean;
+    /** Keep the field's errors instead of clearing them. */
+    keepError?: boolean;
+};
+declare function removeField(form: Form$1, name: Name, options?: RemoveFieldOptions): void;
+/**
+ * Remove field
+ * @param form
+ * @param path
+ * @param options keep-flags to preserve slices of state through the removal
+ */
+declare function removeFieldByPath(form: Form$1, path: Path, options?: RemoveFieldOptions): void;
+/**
+ * Set form initialValues
+ *
+ * Content-based early return: a new reference with equal content (the
+ * re-rendered inline literal) is a no-op, so committed edits survive, while
+ * genuinely changed content swaps the baseline and re-seeds — live values
+ * and tombstones are cleared, touched flags and errors survive.
+ * @param form
+ * @param initialValues
+ */
+declare function setInitialValues(form: Form$1, initialValues: any): void;
+/** Options accepted by {@link reset}. Every flag defaults to `false` —
+ * omitting the object (or any flag) keeps the plain full-reset behavior.
+ * Names mirror react-hook-form's reset options to ease migration. */
+type ResetOptions = {
+    /** Keep the current values of fields that are dirty — differ from the
+     * pre-reset initialValues (the same rule {@link getDirtyFields} applies).
+     * Clean fields fall back to the new initialValues as usual. */
+    keepDirtyValues?: boolean;
+    /** Keep every field's current live value instead of returning to the
+     * baseline (react-hook-form's `keepValues` — a strict superset of
+     * `keepDirtyValues`, which only preserves dirty fields' values).
+     * Dirtiness is recomputed against the post-reset baseline, so kept
+     * values that differ from a newly provided baseline count as dirty. */
+    keepValues?: boolean;
+    /** Ignore a newly provided `initialValues` argument and keep the current
+     * baseline — fields still return to it (react-hook-form's
+     * `keepDefaultValues`). */
+    keepDefaultValues?: boolean;
+    /** Keep the touched set instead of clearing it. */
+    keepTouched?: boolean;
+    /** Keep field errors instead of clearing them. */
+    keepErrors?: boolean;
+    /** Keep the submitted flag (`isSubmitted`) instead of clearing it —
+     * react-hook-form's `keepIsSubmitted`. */
+    keepIsSubmitted?: boolean;
+    /** Keep the last submit's success flag (`isSubmitSuccessful`) instead of
+     * clearing it. */
+    keepIsSubmitSuccessful?: boolean;
+    /** Keep `submitCount` instead of resetting it to 0. */
+    keepSubmitCount?: boolean;
+    /** Keep `isSubmitting` instead of resetting it to false. */
+    keepIsSubmitting?: boolean;
+};
+/**
+ * Reset form
+ * @param form
+ * @param initialValues new baseline — omitted (or undefined), the form
+ *        keeps its current initialValues and fields simply return to them
+ *        (react-hook-form's reset-without-values semantics)
+ * @param options keep-flags to preserve slices of state through the reset
+ */
+declare function reset(form: Form$1, initialValues?: any, options?: ResetOptions): void;
+/** Options accepted by {@link resetField}. The flags default to `false`;
+ * `value` has no default — omitted, the field falls back to initialValues;
+ * provided, the explicit value becomes the live value with no fallback at
+ * all. Mirrors react-hook-form's resetField options (`value` plays their
+ * `defaultValue`'s role) to ease migration. */
+type ResetFieldOptions = {
+    /** Keep the field's touched flag instead of clearing it. */
+    keepTouched?: boolean;
+    /** Keep the field's errors instead of clearing them. */
+    keepErrors?: boolean;
+    /** Explicit post-reset value for the field — never falls back to
+     * initialValues. */
+    value?: any;
+};
+/**
+ * Reset a single field: drop its live value (reads fall back to the
+ * baseline — initialValues, or the schema's parsed output when one
+ * exists, in which case the path is removed from parsedValues and the
+ * initial value pinned back so the field reads initialValues again),
+ * clear its touched flag and errors, and revive the path's removal
+ * tombstones — the inverse of {@link removeFieldByPath}. Other fields
+ * and the submission flags are untouched; see {@link reset} for the
+ * form-wide counterpart.
+ *
+ * @param form
+ * @param name
+ * @param options
+ */
+declare function resetField<T extends Record<string, any> = any, P extends FieldPath<T> | PathSegments = FieldPath<T> | PathSegments>(form: Form$1<T>, name: P, options?: ResetFieldOptions): void;
+
+/**
+ * Set field touched state
+ * @param form
+ * @param name
+ */
+declare function setTouched(form: Form$1, name: Name): void;
+/**
+ * Set field touched state
+ * @param form
+ * @param path
+ */
+declare function setTouchedByPath({ emitter, touched }: Form$1, path: Path): void;
+/**
+ * Check if field has been touched
+ * @param form
+ * @param name
+ */
+declare function hasTouched<T extends Record<string, any> = any, P extends FieldPath<T> | PathSegments = FieldPath<T> | PathSegments>(form: Form$1<T>, name: P): boolean;
+/**
+ * Check if field has been touched
+ * @param form
+ * @param path
+ */
+declare function hasTouchedByPath({ touched }: Form$1, path: Path): boolean;
+/**
+ * Is dirty -- any value differs from initialValues
+ * @param form
+ */
+/**
+ * Get touched fields as user-facing dotted paths ('a.b', 'a.0.c'), unlike
+ * the JSON array keys stored in the touched Set.
+ * @param form
+ * @return array of touched fields' dotted paths
+ */
+declare function getTouchedFields({ touched }: Form$1): string[];
+/**
+ * Is touched -- any field has been touched
+ * @param form
+ */
+declare function isTouched({ touched }: Form$1): boolean;
+
+/**
+ * Is one field dirty — the per-field rule behind `getFieldState`'s
+ * `isDirty` and {@link useIsFieldDirty}: a live value exists at the path
+ * and differs from the field's effective baseline (committed
+ * `shouldDirty: false` baselines included). A leaf under a wholesale
+ * ancestor write reports clean — dirtiness belongs to the branch that
+ * actually diverged, the same attribution {@link getDirtyFields} applies.
+ */
+declare function isFieldDirtyByPath(form: Form$1, path: Path): boolean;
+/**
+ * Is dirty -- any value differs from initialValues
+ * @param form
+ */
+declare function isDirty(form: Form$1): boolean;
+/**
+ * Get dirty fields -- fields whose current value differs from initialValues.
+ * Keys are user-facing dotted paths ('a.b', 'a.0.c'), unlike the JSON array
+ * keys stored in the values Map.
+ * @param form
+ * @return object mapping each dirty field's dotted path to true; the same
+ * reference is returned until the dirty set actually changes
+ */
+declare function getDirtyFields(form: Form$1): Record<string, boolean>;
+
+/**
+ * Set a field value as a user change.
+ *
+ * The write rides the same gated user-change pipeline a user typing into
+ * the field would fire when a field is mounted on the path (registered
+ * through {@link registerFieldMode} — `useField` registers on mount): the
+ * field's effective `mode` (per-field override included) and the form's
+ * `reValidateMode` drive validation exactly as in {@link
+ * userChangeByPath}. With no mounted field on the path it degrades to a
+ * plain value set ({@link setValue}).
+ *
+ * This is the channel for component-library bridges that hand a control a
+ * plain setter bound to a field — they cannot rebuild the gating from
+ * public form state, because the per-field mode override and the
+ * live-error view that gates `reValidateMode` live in the field
+ * registration, not in public state.
+ *
+ * Contrast {@link setValue}: that is the imperative channel — its
+ * `shouldValidate` option kicks the field's validator unconditionally,
+ * ignoring any mode. Functional updaters are the caller's to evaluate
+ * ({@link getValue}).
+ *
+ * `options` carries the same {@link SetFieldOptions}: on the fallback path
+ * (no mounted field) they forward to {@link setValueByPath} wholesale,
+ * while on the mounted-field path only `shouldDirty: false` applies — the
+ * write lands as a commit while the field's own mode gating keeps driving
+ * validation, which is the point of this channel.
+ *
+ * @param form
+ * @param name
+ * @param value
+ * @param options
+ */
+declare function changeValue<T extends Record<string, any> = any, P extends FieldPath<T> | PathSegments = FieldPath<T> | PathSegments>(form: Form$1<T>, name: P, value: PathValueOf<T, P>, options?: SetFieldOptions): void;
+/**
+ * Set a field value as a user change, by parsed path
+ * @param form
+ * @param path
+ * @param value
+ * @param options
+ */
+declare function changeValueByPath(form: Form$1, path: Path, value: any, options?: SetFieldOptions): void;
+/**
+ * Register a mounted field's `mode` override at `path` for user-change
+ * gating ({@link userChangeByPath} / {@link userBlur}). Returns the
+ * registration token for {@link unregisterFieldMode} plus whether the
+ * slot was already occupied — two fields mounted at one path is almost
+ * always a bug: the latest mount's mode governs every user-change write
+ * there, which the React layer warns about in DEV.
+ *
+ * @param form
+ * @param path
+ * @param mode the field's `mode` option, or undefined to follow
+ *        {@link Form.mode}
+ * @return `token` to hand to {@link unregisterFieldMode}; `displaced`
+ *         true when a previous registration at the same path still owned
+ *         the slot
+ */
+declare function registerFieldMode(form: Form$1, path: Path, mode: ValidationMode | undefined): {
+    token: object;
+    displaced: boolean;
+};
+/** Drop a {@link registerFieldMode} registration. A later mount at the
+ * same path keeps its slot: only the entry owned by `token` is removed. */
+declare function unregisterFieldMode(form: Form$1, path: Path, token: object): void;
+/**
+ * Write a bound field's user change by path: the write plus the
+ * mode/reValidateMode-gated validation pipeline — what a bound field's
+ * onChange does when the user types. Reads the effective mode from the
+ * field-mode registry (the latest mount's override governs), so a plain
+ * write happens when no field is registered at `path`. Framework
+ * adapters (React's `useField`, a Solid binding) forward their field
+ * change events here.
+ *
+ * @param form
+ * @param path
+ * @param value
+ */
+declare function userChangeByPath(form: Form$1, path: Path, value: any): void;
+/**
+ * A bound field's blur: mark the path touched, then kick its validator
+ * under the blur-side gate (`mode` `'onBlur'`/`'onTouched'`/`'all'`, or
+ * `reValidateMode: 'onBlur'` while the field carries a live error). The
+ * touched marking is unconditional — a field counts as touched on blur
+ * regardless of mode. Framework adapters forward field blur events here.
+ *
+ * @param form
+ * @param path
+ */
+declare function userBlur(form: Form$1, path: Path): void;
+
+declare function setIsSubmitting(form: Form$1, value: boolean): void;
+declare function incrementSubmitCount(form: Form$1): void;
+declare function setSubmitSuccessful(form: Form$1, value: boolean): void;
+/**
+ * Set the form-level disabled flag and emit a payload-less 'disabled'
+ * event — subscribed fields (useField and the components built on it)
+ * re-render with the merged disabled state: form flag || their own
+ * `disabled` option.
+ * @param form
+ * @param value
+ */
+declare function setDisabled(form: Form$1, value: boolean): void;
+/**
+ * Set the form's user-owned metadata slot (Formik's `status` role): the
+ * payload-less 'status' event wakes {@link useStatus} and any imperative
+ * `subscribe(form, {event: 'status'})` listeners. Nothing else reads or
+ * interprets the value — server session flags, step state, non-field
+ * errors of any shape are all fair game. Starts `undefined`.
+ * @param form
+ * @param value
+ */
+declare function setStatus(form: Form$1, value: any): void;
+/** Submit callbacks for {@link handleSubmit}. All optional — a missing
+ * callback is simply skipped, matching the <Form> component semantics. */
+type HandleSubmitOptions<T extends Record<string, any> = any> = {
+    /** Called after validation passes, before onValidSubmit. */
+    onSubmit?: (values: T, e?: any) => void | Promise<void>;
+    /** Called after validation passes, following a successful onSubmit. */
+    onValidSubmit?: (values: T, e?: any) => void | Promise<void>;
+    /**
+     * Called when validation fails.
+     * @param errors array of {path, type, message} entries in insertion
+     *        order; path is the dotted field path ('a.b', 'list.0'), type is
+     *        the error kind ('custom' for plain string errors, 'native' for
+     *        failed DOM constraint validation), message is the display text
+     * @param values current form values
+     */
+    onInvalidSubmit?: (errors: FieldErrorEntry[], values: T) => void;
+    /**
+     * Called after validation passes and the submit callbacks ran, with the
+     * final (schema-coerced) values — the slot <Form>'s `action` prop uses
+     * to dispatch React 19 server actions with FormData. Runs inside the
+     * same isSubmitting window and is awaited like onSubmit/onValidSubmit.
+     */
+    onAction?: (values: T, e?: any) => void | Promise<void>;
+    /**
+     * Focus the first error field after a failed submit. Defaults to true —
+     * only an explicit `false` disables it. When custom validation fails,
+     * a 'focusError' event carrying the first error's path key is emitted
+     * on the form (bound fields such as <Field> subscribe and focus their
+     * input); when native constraint validation fails, the submitted
+     * form's first ':invalid' control is focused directly.
+     */
+    shouldFocusError?: boolean;
+};
+/**
+ * Create an async submit handler for `form` — the headless counterpart of
+ * the <Form> component's onSubmit wiring.
+ *
+ * Behavior mirrors <Form> exactly: preventDefault when present, then the
+ * submit state machine (isSubmitting/submitCount/isSubmitSuccessful) runs
+ * around native constraint validation (via `e.currentTarget.checkValidity`,
+ * skipped when the target has no checkValidity — e.g. React Native or
+ * toolbar-button submits) and custom validators. Failed validation fires
+ * onInvalidSubmit with the flattened error entries; a passing submit runs
+ * onSubmit then onValidSubmit. Errors thrown by either are swallowed into
+ * isSubmitSuccessful=false rather than rejecting the returned promise.
+ * Failed validation also focuses the offending field (see
+ * {@link HandleSubmitOptions.shouldFocusError}).
+ *
+ * @param form form instance
+ * @param options submit callbacks
+ * @return async event handler, callable without an event object
+ */
+declare function handleSubmit<T extends Record<string, any> = any>(form: Form$1<T>, options?: HandleSubmitOptions<T>): (e?: {
+    preventDefault?: () => void;
+    currentTarget?: any;
+}) => Promise<void>;
 
 /** Type tag of a failed rule, as stored on the resulting FieldError. */
 type RuleType = 'required' | 'min' | 'max' | 'minLength' | 'maxLength' | 'pattern';
@@ -14,55 +507,102 @@ type RuleType = 'required' | 'min' | 'max' | 'minLength' | 'maxLength' | 'patter
  * rule name) instead of only surfacing through the browser's validity
  * bubble, so any design system can render the messages uniformly.
  */
-interface FieldRules {
+type FieldRules = {
     /**
-     * Fails on empty values: `''`, `undefined` or `null` (`0` and `false`
-     * count as filled). 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.
+     * 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; non-strings skip. */
+    /** 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; non-strings skip. */
+    /** 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>>;
-}
+};
 
-interface UseFieldOptions$1<TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | Name = Name> {
+type UseFieldOptions$1<TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments> = {
     form?: Form$1<TValues>;
     name: TPath;
     initialValue?: any;
     shouldUnregister?: boolean;
-    validate?: Validator;
+    /**
+     * Field-level validator. The value argument follows the path: with a
+     * typed form the callback receives `PathValueOf<TValues, TPath>` (the
+     * TanStack-parity inference — `name: 'age'` on a `{age: number}` shape
+     * types `value` as `number`), and falls back to `any` for untyped call
+     * sites (segment arrays, dynamic names). The return shape mirrors
+     * {@link Validator} — an error (string / FieldError / mixed array) or
+     * undefined when valid, possibly a Promise for async validation. The
+     * second argument carries the validation context (`meta.signal` aborts
+     * when the round is superseded).
+     */
+    validate?: (value: PathValueOf<TValues, TPath>, meta: {
+        form: Form$1<TValues>;
+        path: Path;
+        signal: AbortSignal;
+    }) => ReturnType<Validator>;
     /**
      * Declarative rules (required/min/max/minLength/maxLength/pattern),
-     * compiled into a validator that runs before `validate` — both sources'
-     * errors merge into one FieldError[], rules errors ahead. Failures land
-     * in the form's error state with the given or default messages.
+     * compiled into a synchronous validator. `required` is special: it runs
+     * immediately on every kick — never debounced — and while it fails,
+     * `validate` is skipped (the expensive check never sees an empty value).
+     * The other rules compose with `validate` — rules run first, then
+     * `validate` (awaited when async), merging both sources' errors with
+     * rules errors ahead. Failures land in the form's error state with the
+     * given or default messages.
      */
     rules?: FieldRules;
     /**
      * Milliseconds to debounce this field's validation kicks. Defaults to 0
      * (validate immediately); while the timer is pending the field counts as
      * validating, so `trigger`/`ensureValidate` wait out the window. Only the
-     * last kick inside the window runs the validator.
+     * last kick inside the window runs the validator. The `required` rule is
+     * exempt: it runs synchronously on every kick, so a required failure
+     * shows immediately instead of waiting out the window.
      */
     validateDebounce?: number;
+    /**
+     * Run this field's debounced validator even when its `required` gate
+     * failed — TanStack Form's `asyncAlways`. The gate's errors land
+     * immediately (never debounced) and the validator's own result lands
+     * alongside them, per-source: a passing async round clears only its
+     * own errors while the gate's verdict stays. Falls back to the
+     * form-level `createForm({asyncAlways})` flag when omitted, so a field
+     * opts out with `asyncAlways: false`. The use case: the cheap format
+     * check fails (gate) but the expensive backend check should still run
+     * ("not in the right shape — and the backend says taken, too").
+     */
+    asyncAlways?: boolean;
     /**
      * Milliseconds to delay showing a newly appearing error in the render
      * layer (`error`/`errorObject`/`errors` stay undefined/empty until the
@@ -78,6 +618,22 @@ interface UseFieldOptions$1<TValues extends Record<string, any> = any, TPath ext
      * `disabled`. A field cannot opt out of a disabled form.
      */
     disabled?: boolean;
+    /**
+     * Uncontrolled mode: the field never subscribes to its own value, so
+     * typing re-renders nothing — the store still carries every write
+     * (getValues/submit/validation read it), and errors/touched/disabled/
+     * validating still re-render the field like react-hook-form's
+     * `register`. The result's `value` is the mount-time snapshot (initial
+     * value seed or baseline); it never refreshes, and bulk operations
+     * (reset/setInitialValues) sync the DOM element directly through the
+     * `focusRef`-held element instead of a render — the register-style
+     * contract, RHF's reset clears the input the same way. Attach the
+     * result with `<input defaultValue={field.value} ref={field.focusRef}>`
+     * -style binding (no `value` prop), exactly like <Field uncontrolled />
+     * does. The DOM sync writes the raw stored value (file inputs are
+     * skipped); read live values with useValue/getValues.
+     */
+    uncontrolled?: boolean;
     /**
      * Field-level validation mode override: when given, this field validates
      * on its own schedule instead of `form.mode` — every other field keeps
@@ -111,13 +667,22 @@ interface UseFieldOptions$1<TValues extends Record<string, any> = any, TPath ext
      * the field's own path is a no-op (its own change already validates it).
      */
     validateDeps?: FieldPath<TValues>[];
-}
+    /**
+     * Validate this field once on mount instead of waiting for the first
+     * submit/change — errors show immediately for an untouched field.
+     * Overrides the form-level `createForm({validateOnMount})` flag in
+     * either direction (`false` opts a field out of a validating form).
+     * While an async `initialValues` source is still pending the kick waits
+     * for the resolved baseline; a field unmounted in between never kicks.
+     */
+    validateOnMount?: boolean;
+};
 /**
  * The result of {@link useField}. Deliberately a closed shape: no index
  * signature, so a typo'd property access (`field.vlaue`) is a type error
  * instead of silently reading `undefined`.
  */
-interface UseFieldResult<TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | Name = Name> {
+type UseFieldResult<TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments> = {
     /** The form instance this field is bound to (explicit prop or context) —
      * handy for consumers that need direct access to the headless API. */
     form: Form$1<TValues>;
@@ -130,6 +695,22 @@ interface UseFieldResult<TValues extends Record<string, any> = any, TPath extend
      * and `errorObject` are its first entry. Empty (and reference-stable)
      * when the field has no errors. */
     errors: FieldError[];
+    /**
+     * Whether the field is dirty: its live value exists and differs from
+     * the field's effective baseline (the same per-field rule
+     * `getFieldState(form, name).isDirty` applies — committed
+     * `shouldDirty: false` baselines included). Live in controlled mode;
+     * pinned at mount in uncontrolled mode (like `value`) so typing never
+     * re-renders the field — {@link useIsFieldDirty} is the live scoped
+     * channel for either mode.
+     */
+    isDirty: boolean;
+    /**
+     * Whether a validator round for this field is currently in flight —
+     * a pending debounce window or an unresolved async validator (the
+     * `getFieldState(form, name).isValidating` reading, made reactive).
+     */
+    validating: boolean;
     onChange: (v: any) => void;
     onBlur: () => void;
     name: string;
@@ -137,15 +718,51 @@ interface UseFieldResult<TValues extends Record<string, any> = any, TPath extend
      * toggled by `setDisabled`) OR-ed with this field's own `disabled`
      * option, updated live through the form's event core. */
     disabled: boolean;
-}
-declare function useField<TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | Name = Name>(options: UseFieldOptions$1<TValues, TPath>): UseFieldResult<TValues, TPath>;
+    /**
+     * Callback ref carrying the focus channel: attach it to your input
+     * element (`<input ref={field.focusRef} />`) so `setFocus` and a failed
+     * submit's first-error auto-focus (`shouldFocusError`) can focus this
+     * headless field — the same 'focusError' wiring `<Field>` performs for
+     * its own input. Without it, focus requests aimed at this field are
+     * silent no-ops, matching `setFocus`'s contract: focusing a field
+     * whose element is not bound neither throws nor focuses anything.
+     */
+    focusRef: (el: any) => void;
+};
+declare function useField<TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments>(options: UseFieldOptions$1<TValues, TPath>): UseFieldResult<TValues, TPath>;
 
-interface FieldArrayItem {
+type FieldArrayItem<K extends string> = {
     id: string;
     index: number;
-}
-interface UseFieldArrayResult {
-    fields: FieldArrayItem[];
+} & Record<K, string>;
+/** Options accepted by {@link useFieldArray} and the per-instance hook
+ * returned by `createFormContext()`. */
+type UseFieldArrayOptions<K extends string = 'id'> = {
+    name: Name;
+    form?: Form$1;
+    /**
+     * Property name the stable row key is exposed under on each `fields`
+     * entry (react-hook-form's `keyName`): defaults to `'id'`, a custom
+     * name (e.g. `'key'`) avoids clashing with a row data field of the
+     * same name. The underlying id is unchanged.
+     */
+    keyName?: K;
+    /**
+     * Declarative rules validated against the whole array value
+     * (react-hook-form's `useFieldArray` `rules`): `required` fails on an
+     * empty array, `minLength`/`maxLength` read the array's length. Checked
+     * on submit and `trigger`, like every registered validator.
+     */
+    rules?: FieldRules;
+    /**
+     * Whether unmounting this array removes its branch. Defaults to the
+     * form-level `shouldUnregister` — tombstone (drop values) like a bound
+     * field's unmount; pass `false` to keep the values.
+     */
+    shouldUnregister?: boolean;
+};
+type UseFieldArrayResult<K extends string = 'id'> = {
+    fields: FieldArrayItem<K>[];
     append: (value: any) => void;
     prepend: (value: any) => void;
     insert: (index: number, value: any) => void;
@@ -154,18 +771,15 @@ interface UseFieldArrayResult {
     move: (from: number, to: number) => void;
     replace: (values: any[]) => void;
     update: (index: number, value: any) => void;
-}
-declare function useFieldArray(options: {
-    name: Name;
-    form?: Form$1;
-}): UseFieldArrayResult;
+};
+declare function useFieldArray<K extends string = 'id'>(options: UseFieldArrayOptions<K>): UseFieldArrayResult<K>;
 /**
  * The result of {@link useFieldArrayItem}. Mirrors the {@link useField}
  * return shape (`value`/`errors`/`error`) plus the row's `index` and
  * `name` (path key) so nested fields can build on it —
  * `useField({name: ['tags', item.index, 'label']})`.
  */
-interface UseFieldArrayItemResult<TValue = any> {
+type UseFieldArrayItemResult<TValue = any> = {
     value: TValue;
     /** Overwrite this row's value in place (same array-layer write as
      * `update(index, value)`: the row's id and position are kept). */
@@ -183,7 +797,7 @@ interface UseFieldArrayItemResult<TValue = any> {
      * undefined and nothing writes the dangling path. */
     index: number;
     form: Form$1;
-}
+};
 /**
  * Subscribe to a single row of a {@link useFieldArray} field — the
  * per-item counterpart `useFieldArray` alone cannot offer. `useFieldArray`
@@ -215,8 +829,8 @@ declare function useFieldArrayItem<TValue = any>(options: {
     form?: Form$1;
 }): UseFieldArrayItemResult<TValue>;
 
-declare const FormContext: React.Context<any>;
-declare const FormProvider: React.Provider<any>;
+declare const FormContext: React.Context<Form$1<any> | null>;
+declare const FormProvider: React.Provider<Form$1<any> | null>;
 /**
  * Read the form from the module-level {@link FormContext}. Pass the values
  * shape — `useFormContext<Values>()` — to get a fully typed `Form<Values>`
@@ -249,12 +863,15 @@ declare function createFormContext<TValues extends Record<string, any> = any>():
         children: ReactNode;
     }) => ReactNode;
     useFormContext: () => Form$1<TValues>;
-    useField: <TPath extends FieldPath<TValues> | Name = Name>(options: {
+    useField: <TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments>(options: {
         name: TPath;
     } & Omit<UseFieldOptions$1<TValues, TPath>, "form">) => UseFieldResult<TValues, TPath>;
-    useFieldArray: (options: {
+    useFieldArray: <K extends string = "id">(options: {
         name: FieldPath<TValues> | Name;
-    }) => UseFieldArrayResult;
+        keyName?: K;
+        rules?: FieldRules;
+        shouldUnregister?: boolean;
+    }) => UseFieldArrayResult<K>;
     useFieldArrayItem: <TValue = any>(options: {
         name: FieldPath<TValues> | Name;
         id: string;
@@ -264,6 +881,70 @@ declare const CheckboxGroupContext: React.Context<any>;
 declare const CheckboxGroupProvider: React.Provider<any>;
 declare function useCheckboxGroupContext(): any;
 
+/** Subscription granularity for {@link onPathEvent}.
+ * - `'leaf'`: the subscriber reads exactly one key ({@link
+ *   useValueByPath}); only writes at that key or above it can change what
+ *   it reads.
+ * - `'branch'`: the subscriber aggregates a whole subtree below a key
+ *   ({@link useFieldArray}); descendant writes matter too. */
+type WatchScope = 'leaf' | 'branch';
+/** Events {@link subscribe} can watch. `'errors'` and `'touched'` are
+ * stored per exact key, so they match exact keys ({@link onKeyEvent});
+ * `'change'`, `'validating'`, `'submitting'`, `'submitCount'`,
+ * `'disabled'`, `'status'` and `'submitSuccessful'` go through
+ * {@link onPathEvent}. `'validating'` carries paths (one per async
+ * validator round) and matches by path exactly like `'change'`;
+ * `'submitting'`, `'submitCount'`, `'disabled'`, `'status'` and
+ * `'submitSuccessful'` are payload-less broadcasts, so `name` never
+ * narrows them — every subscriber hears every emission. */
+type SubscribeEvent = 'change' | 'errors' | 'touched' | 'validating' | 'submitting' | 'submitCount' | 'submitSuccessful' | 'disabled' | 'status' | 'loading';
+/** Options accepted by {@link subscribe}. */
+type SubscribeOptions = {
+    /** Path (or list of paths) to watch. Omit to receive every emission of
+     * `event`, payload-less broadcasts included. A single segments path
+     * (`['tags', 0]`) and a list of names (`['tags', 'user.name']`) are told
+     * apart by the same rule `trigger` uses: only a segments path can hold
+     * a number. */
+    name?: Name | Name[];
+    /** Event to watch. Defaults to `'change'`. */
+    event?: SubscribeEvent;
+    /** Which writes around `name` are relevant — `'leaf'` or `'branch'`.
+     * Only meaningful for the path-carrying events `'change'` and
+     * `'validating'`: `'errors'`/`'touched'` match exact keys and
+     * `'submitting'`/`'submitCount'`/`'disabled'`/`'status'`/
+     * `'submitSuccessful'` are payload-less. Defaults to `'branch'` — the
+     * intuitive linkage semantics, where subscribing to `'tags'` means the
+     * whole branch. */
+    scope?: WatchScope;
+    /** Invoked with no arguments after each matching emission. Read fresh
+     * state through the `get*` readers inside it. */
+    callback: () => void;
+};
+/**
+ * Subscribe to form events imperatively — the non-render counterpart of
+ * the `use*` hooks: linkages and side effects (province changed → clear
+ * city, autosave, analytics) run without mounting a watching component.
+ *
+ * Without `name`, `callback` fires on every `event` emission, payload-less
+ * broadcasts (reset, setInitialValues) included. With `name`, matching
+ * follows the event's shape: `'errors'`/`'touched'` match the exact key
+ * ({@link onKeyEvent}) — another field's error never wakes this
+ * subscriber — while `'change'`/`'validating'`/`'submitting'`/
+ * `'submitCount'`/`'disabled'`/`'submitSuccessful'` go through
+ * {@link onPathEvent}, so the default `'branch'` scope wakes a `'tags'`
+ * subscriber when any `tags.*` descendant is written. `'validating'`
+ * carries a path per validator round and narrows by path like
+ * `'change'`; `'disabled'`/`'submitSuccessful'` (like `'submitting'`)
+ * are payload-less broadcasts that every named subscriber receives. A
+ * `name` array builds one subscription per path and the returned
+ * function unsubscribes them all.
+ *
+ * @param form the form to watch
+ * @param options event, name(s), scope and callback
+ * @return unsubscribe function
+ */
+declare function subscribe(form: Form$1, options: SubscribeOptions): () => void;
+
 /**
  * Create a form instance bound to this component.
  *
@@ -279,6 +960,23 @@ declare function useCheckboxGroupContext(): any;
 declare function useForm<T extends Record<string, any> = any>(options?: Options<T> & {
     values?: T;
 }): Form$1<T>;
+/**
+ * Shared core of {@link useWatch} and the path-scoped hooks: a
+ * useSyncExternalStore binding over a custom event subscription.
+ * `subscribeFactory` receives the invalidate callback (drop the snapshot
+ * cache, then notify React) and returns its unsubscribe function, so the
+ * core stays identical whether the subscription is global or scoped to
+ * one path.
+ *
+ * The optional `isEqual` comparator redirects `invalidate`: instead of
+ * dropping the cache and waking React unconditionally, an event first
+ * recomputes the getter and asks `isEqual` whether anything observable
+ * changed — an equal verdict keeps the cached snapshot and skips the
+ * notify entirely (no render at all), an unequal one stores the fresh
+ * snapshot and notifies. Omitted, the historical drop-and-notify pipeline
+ * runs byte-for-byte unchanged.
+ */
+declare function useWatchCore<T>(subscribeFactory: (invalidate: () => void) => () => void, getter: () => T, isEqual?: (prev: T, next: T) => boolean): T;
 /**
  * Subscribe to a form event and keep the component's snapshot of `getter()`
  * in sync with the form state.
@@ -286,20 +984,53 @@ declare function useForm<T extends Record<string, any> = any>(options?: Options<
  * Built on useSyncExternalStore, so snapshots taken while React renders are
  * guaranteed consistent (no tearing under concurrent rendering) and changes
  * emitted before the subscription effect runs are still picked up.
+ *
+ * The first argument is the form for the unified `fn(form, ...)` context
+ * shape every hook shares; the raw emitter form remains accepted for
+ * back-compat and for subscription sources that are not a full form.
+ *
+ * By default the re-render surface is the event's own scope: every emit
+ * the subscription hears drops the snapshot cache and wakes React, which
+ * then bails out when the recomputed snapshot is reference-identical
+ * (Object.is) — the path/leaf scoping every built-in reader relies on.
+ * The optional `isEqual` comparator exists for wide-scope getters that
+ * return a fresh reference per call (a whole-values selector, say): each
+ * event recomputes the getter and asks `isEqual` whether the result is
+ * observably the same, and an equal verdict skips notifying React
+ * altogether — no render, not even a bailed-out one. An unequal verdict
+ * stores the new snapshot and re-renders. Same contract as TanStack's
+ * `useSelector` compare. Omitted, behavior is unchanged.
  */
-declare function useWatch<T>(emitter: EventEmitter, event: string, getter: () => T): T;
+declare function useWatch<T>(formOrEmitter: Form$1 | EventEmitter<FormEvents>, event: SubscribeEvent, getter: () => T, isEqual?: (prev: T, next: T) => boolean): T;
+/** Options for {@link useValue} and {@link useValueByPath}. */
+type UseValueOptions<T extends Record<string, any> = any, P extends FieldPath<T> | PathSegments = FieldPath<T> | PathSegments> = {
+    /** Value to return while the field reads undefined — react-hook-form's
+     * `useWatch` `defaultValue`: an untouched, never-seeded field reads
+     * this instead of `undefined`. */
+    defaultValue?: PathValueOf<T, P>;
+    /** Watch descendants too (react-hook-form's `exact: false`): a write
+     * to `a.b` invalidates a `useValue(form, 'a')` read, and the read
+     * resolves the merged subtree (the copy-on-write `getValues` tree) so
+     * descendant edits show up in the result. Defaults to true — the leaf
+     * scope, where only the exact key and its ancestors invalidate (the
+     * long-standing behavior). */
+    exact?: boolean;
+};
 /**
  * Get field value state
  */
-declare function useValue<T extends Record<string, any> = any, P extends FieldPath<T> | Name = Name>(form: Form$1<T>, name: P): PathValueOf<T, P>;
+declare function useValue<T extends Record<string, any> = any, P extends FieldPath<T> | PathSegments = FieldPath<T> | PathSegments>(form: Form$1<T>, name: P, options?: UseValueOptions<T, P>): PathValueOf<T, P>;
 /**
  * Get field value state by path
  */
-declare function useValueByPath(form: Form$1, path: Path): any;
+declare function useValueByPath(form: Form$1, path: Path, options?: {
+    defaultValue?: any;
+    exact?: boolean;
+}): any;
 /**
  * Get field touched state
  */
-declare function useTouched<T extends Record<string, any> = any, P extends FieldPath<T> | Name = Name>(form: Form$1<T>, name: P): boolean;
+declare function useTouched<T extends Record<string, any> = any, P extends FieldPath<T> | PathSegments = FieldPath<T> | PathSegments>(form: Form$1<T>, name: P): boolean;
 /**
  * Get field touched state by path
  */
@@ -308,7 +1039,7 @@ declare function useTouchedByPath(form: Form$1, path: Path): boolean;
  * Get field error message state
  * @return current error's message string (display text), or undefined
  */
-declare function useError<T extends Record<string, any> = any, P extends FieldPath<T> | Name = Name>(form: Form$1<T>, name: P): string | undefined;
+declare function useError<T extends Record<string, any> = any, P extends FieldPath<T> | PathSegments = FieldPath<T> | PathSegments>(form: Form$1<T>, name: P): string | undefined;
 /**
  * Get field error state by path
  * @return current FieldError object ({type, message}), or undefined
@@ -319,7 +1050,7 @@ declare function useErrorByPath(form: Form$1, path: Path): FieldError | undefine
  * @return every error registered for the field (insertion order); an empty
  *         array when the field has none
  */
-declare function useFieldErrors<T extends Record<string, any> = any, P extends FieldPath<T> | Name = Name>(form: Form$1<T>, name: P): FieldError[];
+declare function useFieldErrors<T extends Record<string, any> = any, P extends FieldPath<T> | PathSegments = FieldPath<T> | PathSegments>(form: Form$1<T>, name: P): FieldError[];
 /**
  * Get all field errors by path
  * @return every error registered for the field (insertion order); an empty
@@ -327,6 +1058,21 @@ declare function useFieldErrors<T extends Record<string, any> = any, P extends F
  */
 declare function useFieldErrorsByPath(form: Form$1, path: Path): FieldError[];
 declare function useIsDirty(form: Form$1): boolean;
+/**
+ * Get whether one field is dirty: its live value exists and differs from
+ * the field's effective baseline — the same per-field rule
+ * `getFieldState(form, name).isDirty` applies (committed
+ * `shouldDirty: false` baselines included). Subscribes to 'change' at
+ * leaf scope like {@link useValue}: own-key and ancestor writes re-check
+ * the flag, payload-less broadcasts (reset, setInitialValues) always
+ * sync, and writes elsewhere never re-render it.
+ */
+declare function useIsFieldDirty<T extends Record<string, any> = any, P extends FieldPath<T> | PathSegments = FieldPath<T> | PathSegments>(form: Form$1<T>, name: P): boolean;
+/**
+ * Get whether one field is dirty, by parsed path. See {@link
+ * useIsFieldDirty}.
+ */
+declare function useIsFieldDirtyByPath(form: Form$1, path: Path): boolean;
 /**
  * Get dirty fields state -- object mapping each dirty field's user-facing
  * dotted path ('a.b', 'a.0.c') to true; recalculated after 'change' events
@@ -337,8 +1083,76 @@ declare function useDirtyFields(form: Form$1): Record<string, boolean>;
  * paths ('a.b', 'a.0.c'); recalculated after 'touched' events
  */
 declare function useTouchedFields(form: Form$1): string[];
+/**
+ * Aggregate snapshot of the whole form's state flags — the one-subscription
+ * counterpart of react-hook-form's `formState` object (no errors object;
+ * per-field error state stays with `useError`/`useFieldErrors`, and
+ * `hasErrors`/`isValid` cover the whole-form questions).
+ *
+ * Recomputed on every state-bearing event; the field-wise comparator keeps
+ * the returned reference stable while nothing observably changed, so
+ * `useFormState(form).isDirty` re-renders no more often than the dedicated
+ * {@link useIsDirty}. Cheaper than calling the granular hooks one by one
+ * (one subscription and one snapshot instead of one per flag).
+ */
+type FormState = {
+    /** Any live value differs from its baseline (see {@link isDirty}). */
+    isDirty: boolean;
+    /** Dirty fields keyed by user-facing dotted path ('a.b', 'a.0.c'). */
+    dirtyFields: Record<string, boolean>;
+    /** At least one field is touched. */
+    isTouched: boolean;
+    /** Touched fields' user-facing dotted paths. */
+    touchedFields: string[];
+    /** Any error registered (field or form level). */
+    hasErrors: boolean;
+    /** No errors are registered — react-hook-form's `isValid` semantics.
+     * In-flight validation is NOT factored in ({@link isValidating} is the
+     * separate signal; async rounds temporarily pass this flag like RHF's). */
+    isValid: boolean;
+    isSubmitting: boolean;
+    /**
+     * Whether a submit has been attempted on this form — set on the first
+     * `handleSubmit` call (validation outcome aside) and cleared by
+     * `reset`, react-hook-form's `formState.isSubmitted` semantics. Read
+     * after a failed submit to render a "fix the errors below" panel.
+     */
+    isSubmitted: boolean;
+    /** Any validation round is running (field, form-level, or a pending
+     * debounce window). */
+    isValidating: boolean;
+    isSubmitSuccessful: boolean | undefined;
+    submitCount: number;
+    /** Async initialValues still pending ({@link Form.isLoading}). */
+    isLoading: boolean;
+    /** The form-level disabled flag (fields OR their own `disabled`). */
+    disabled: boolean;
+};
+declare function useFormState(form: Form$1): FormState;
 declare function useHasErrors(form: Form$1): boolean;
+/**
+ * Get whether the form currently has no errors — react-hook-form's
+ * `formState.isValid` counterpart. Subscribes to the `'errors'` event only;
+ * in-flight validation does not flip it (see {@link useIsValidating}).
+ */
+declare function useIsValid(form: Form$1): boolean;
 declare function useIsSubmitting(form: Form$1): boolean;
+/**
+ * Get whether an async {@link Options.initialValues} source is still
+ * pending — the flag a loading skeleton or a disabled submit button gates
+ * on until the resolved baseline lands. Subscribes to the 'loading' event
+ * the core emits around the resolution cycle.
+ */
+declare function useIsLoading(form: Form$1): boolean;
+/**
+ * Get the form's user-owned metadata slot reactively (Formik's `status`
+ * counterpart): any value the app stores through {@link setStatus} —
+ * server session flags, wizard step state, non-field errors. Subscribes
+ * to the payload-less 'status' event, so unrelated events never re-render
+ * the caller, and the returned reference is stable between writes that
+ * store an equal value (useSyncExternalStore's Object.is bailout).
+ */
+declare function useStatus<T = any>(form: Form$1): T;
 /**
  * Get whether the form accepts a submit right now:
  * `!isSubmitting && !hasErrors`. This is the single flag a submit
@@ -351,59 +1165,112 @@ declare function useIsSubmitting(form: Form$1): boolean;
  */
 declare function useCanSubmit(form: Form$1): boolean;
 declare function useSubmitCount(form: Form$1): number;
+/**
+ * Get whether any validation round is currently running: a field
+ * validator's pending `validateDebounce` window, an async field validator
+ * still in flight, or the form-level validate's debounce window / in-flight
+ * round — every one of them holds a key in `form.validating`, and the
+ * 'validating' events they emit (field rounds with a path payload, the
+ * form-level round as a payload-less broadcast) are what this subscribes
+ * to. The boolean snapshot is Object.is-stable, so churn among the marks
+ * (a second field opening while the first settles) costs no render while
+ * the flag holds. This is the flag a submit button disables itself on, or
+ * spins a spinner with, through the pre-submit validation pass — it flips
+ * true the moment the first round opens and back false when the last one
+ * settles.
+ */
+declare function useIsValidating(form: Form$1): boolean;
+/**
+ * Get whether the last submit succeeded: `true` once a submit's validation
+ * and `onSubmit` completed without throwing, `false` after a failed submit
+ * (validation rejection or a thrown callback) and before any submit ran —
+ * the falsy reading of the undefined initial/reset state. Subscribes to
+ * the 'submitSuccessful' event the core's setSubmitSuccessful emits, so
+ * the flag flips in the same tick the outcome lands: the usual consumers
+ * are a success banner and a redirect-on-success effect.
+ */
+declare function useIsSubmitSuccessful(form: Form$1): boolean;
+/**
+ * Get the form-level error message: the first error stored under the
+ * reserved {@link FORM_ERROR} key, as display text — or undefined while
+ * the slot is clean. That key is where a form-level `validate` record's
+ * `_form` entry lands and where the Standard Schema adapter drops
+ * path-less issues, so errors that belong to no single field still have a
+ * reader. The classic usage renders it once above the submit button —
+ * `useFormError(form) || null` — and the imperative twin is
+ * `getError(form, FORM_ERROR)`.
+ */
+declare function useFormError(form: Form$1): string | undefined;
+/**
+ * Get every form-level error: all errors stored under the reserved
+ * {@link FORM_ERROR} key (insertion order), an empty array when the slot
+ * is clean. The plural twin of {@link useFormError} for forms that stack
+ * several form-level issues — each path-less Standard Schema issue lands
+ * in this slot. The array reference is stable between unrelated events
+ * (the stored array or a shared empty constant), so consumers can memo on
+ * it; the imperative counterpart is `getFieldErrors(form, FORM_ERROR)`.
+ */
+declare function useFormErrors(form: Form$1): FieldError[];
 
-/** Subscription granularity for {@link onPathEvent}.
- * - `'leaf'`: the subscriber reads exactly one key ({@link
- *   useValueByPath}); only writes at that key or above it can change what
- *   it reads.
- * - `'branch'`: the subscriber aggregates a whole subtree below a key
- *   ({@link useFieldArray}); descendant writes matter too. */
-type WatchScope = 'leaf' | 'branch';
-/** Events {@link subscribe} can watch. `'errors'` and `'touched'` are
- * stored per exact key, so they match exact keys ({@link onKeyEvent});
- * `'change'`, `'submitting'` and `'submitCount'` carry paths and go
- * through {@link onPathEvent}. */
-type SubscribeEvent = 'change' | 'errors' | 'touched' | 'submitting' | 'submitCount';
-/** Options accepted by {@link subscribe}. */
-type SubscribeOptions = {
-    /** Path (or list of paths) to watch. Omit to receive every emission of
-     * `event`, payload-less broadcasts included. A single segments path
-     * (`['tags', 0]`) and a list of names (`['tags', 'user.name']`) are told
-     * apart by the same rule `trigger` uses: only a segments path can hold
-     * a number. */
-    name?: Name | Name[];
-    /** Event to watch. Defaults to `'change'`. */
-    event?: SubscribeEvent;
-    /** Which writes around `name` are relevant — `'leaf'` or `'branch'`.
-     * Only meaningful for `'change'`: `'errors'`/`'touched'` match exact
-     * keys and `'submitting'`/`'submitCount'` are payload-less. Defaults to
-     * `'branch'` — the intuitive linkage semantics, where subscribing to
-     * `'tags'` means the whole branch. */
-    scope?: WatchScope;
-    /** Invoked with no arguments after each matching emission. Read fresh
-     * state through the `get*` readers inside it. */
-    callback: () => void;
+/**
+ * Options accepted by {@link useTransform}.
+ */
+type UseTransformOptions<TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments, TDisplay = PathValueOf<TValues, TPath>> = {
+    /**
+     * Map the form's stored (raw) value to the display value the control
+     * renders — the read direction. Omitted: the raw value is displayed
+     * as-is (identity).
+     */
+    toDisplay?: (raw: PathValueOf<TValues, TPath>) => TDisplay;
+    /**
+     * Map a display value back to the raw value written into the form —
+     * the write direction. Omitted: the display value is written as-is
+     * (identity). The round trip should be an identity
+     * (`toDisplay(fromDisplay(x)) === x`); a store value the transform
+     * cannot invert (e.g. `undefined` for a not-yet-edited field) must be
+     * handled by `toDisplay`, since it runs first.
+     */
+    fromDisplay?: (display: TDisplay) => PathValueOf<TValues, TPath>;
 };
 /**
- * Subscribe to form events imperatively — the non-render counterpart of
- * the `use*` hooks: linkages and side effects (province changed → clear
- * city, autosave, analytics) run without mounting a watching component.
+ * Bind a control to a field whose stored value and display value differ
+ * — TanStack Form's `useTransform` counterpart, with the round trip made
+ * explicit: `toDisplay` maps the store value to what the control shows,
+ * `fromDisplay` maps the control's display value back to what the store
+ * holds. The store always carries the raw typed value, so
+ * `getValues`/submit/validation never see display representations.
  *
- * Without `name`, `callback` fires on every `event` emission, payload-less
- * broadcasts (reset, setInitialValues) included. With `name`, matching
- * follows the event's shape: `'errors'`/`'touched'` match the exact key
- * ({@link onKeyEvent}) — another field's error never wakes this
- * subscriber — while `'change'`/`'submitting'`/`'submitCount'` go through
- * {@link onPathEvent}, so the default `'branch'` scope wakes a `'tags'`
- * subscriber when any `tags.*` descendant is written. A `name` array
- * builds one subscription per path and the returned function unsubscribes
- * them all.
+ * ```jsx
+ * const age = useTransform(form, 'age', {
+ *   toDisplay: (raw: number) => String(raw),
+ *   fromDisplay: (display: string) => Number(display)
+ * });
+ * <input value={age.value} onChange={e => age.onChange(e.target.value)} />
+ * ```
  *
- * @param form the form to watch
- * @param options event, name(s), scope and callback
- * @return unsubscribe function
+ * `value` subscribes to 'change' at leaf scope exactly like a controlled
+ * `useField` value — typing, programmatic `setValue` and ancestor writes
+ * all re-derive it, writes elsewhere never re-render it. `onChange`
+ * writes through `userChangeByPath` (the user-change channel): with a
+ * field mounted at the same path the mode/reValidateMode-gated
+ * validation fires exactly as if the user typed into a bound field; with
+ * no mounted field it degrades to a plain value write. Touched marking
+ * stays a blur concern — pair this with `useField` at the same path, or
+ * call `setTouched`, when blur semantics matter.
+ *
+ * The transform functions are read fresh on every render (inline
+ * closures work), and `value` is recomputed per render — keep display
+ * values primitive (string/number) so React's equal-state bailout holds.
+ *
+ * @param form the form instance (explicit; the hook is headless — no
+ *        context read, no provider required)
+ * @param name the field's path (dotted string or segments)
+ * @param options the two mapping directions; both optional (identity)
  */
-declare function subscribe(form: Form$1, options: SubscribeOptions): () => void;
+declare function useTransform<TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments, TDisplay = PathValueOf<TValues, TPath>>(form: Form$1<TValues>, name: TPath, options?: UseTransformOptions<TValues, TPath, TDisplay>): {
+    value: TDisplay;
+    onChange: (display: TDisplay) => void;
+};
 
 /**
  * Props for <Form>.
@@ -419,7 +1286,7 @@ declare function subscribe(form: Form$1, options: SubscribeOptions): () => void;
  * The submit flow itself lives in the headless `handleSubmit` (see form.ts);
  * this component is a thin wrapper that binds it to the rendered <form>.
  */
-interface FormProps<T extends Record<string, any> = any> extends Omit<React.FormHTMLAttributes<HTMLFormElement>, 'onSubmit'> {
+type FormProps<T extends Record<string, any> = any> = Omit<React.FormHTMLAttributes<HTMLFormElement>, 'onSubmit'> & {
     form?: Form$1<T>;
     /**
      * Provide into an isolated context from `createFormContext()` instead of
@@ -431,7 +1298,39 @@ interface FormProps<T extends Record<string, any> = any> extends Omit<React.Form
      * the form lands in the module-level FormContext as before.
      */
     context?: React.Context<Form$1<any> | null>;
-    initialValues?: T;
+    /**
+     * The values baseline — a sync object, a Promise, or a thunk returning
+     * either ({@link Options.initialValues}). Async sources render the form
+     * empty and gate on `form.isLoading` until they resolve.
+     */
+    initialValues?: T | Promise<T> | (() => T | Promise<T>);
+    /**
+     * Form-level default for a bound field's unmount behavior
+     * ({@link Options.shouldUnregister}): `true` (the default) tombstones
+     * unmounted fields, `false` keeps their values.
+     */
+    shouldUnregister?: boolean;
+    /**
+     * Validate on mount (see {@link Options.validateOnMount}): every
+     * mounted field with a validator kicks once after mount and the
+     * form-level `validate` (if any) runs once. A field's own
+     * `validateOnMount` prop overrides this flag.
+     */
+    validateOnMount?: boolean;
+    /**
+     * Disable every bound field: the form-level flag fields OR with their
+     * own `disabled` option (a field cannot opt out). Seeded at create and
+     * kept in sync while this prop changes (undefined leaves the current
+     * flag untouched — toggle at runtime with `setDisabled`).
+     */
+    disabled?: boolean;
+    /**
+     * Form-level default for field validation's `asyncAlways`: a field
+     * whose `required` gate failed still runs its debounced validator, its
+     * result landing per-source alongside the gate's errors. A field's own
+     * `asyncAlways` prop overrides this flag.
+     */
+    asyncAlways?: boolean;
     /**
      * Controlled external values. When the `values` reference changes, the
      * new object is synced into the form (via setInitialValues semantics):
@@ -446,6 +1345,16 @@ interface FormProps<T extends Record<string, any> = any> extends Omit<React.Form
     onSubmit?: (values: T, e: React.FormEvent) => void | Promise<void>;
     /** May be async, same as onSubmit. */
     onValidSubmit?: (values: T, e: React.FormEvent) => void | Promise<void>;
+    /**
+     * React 19 Server Action target: after validation passes (and after
+     * onSubmit/onValidSubmit), the validated, schema-coerced values are
+     * converted to FormData ({@link formDataFromValues} — files, arrays and
+     * nested objects included) and dispatched to this callback, e.g.
+     * `action={createUser}` for a server action or
+     * `action={formData => startTransition(() => dispatch(formData))}` in a
+     * useActionState bridge. `isSubmitting` covers the whole flight.
+     */
+    action?: (formData: FormData) => void | Promise<void>;
     /**
      * Called when validation fails.
      * @param errors array of {path, type, message} entries in insertion
@@ -466,8 +1375,31 @@ interface FormProps<T extends Record<string, any> = any> extends Omit<React.Form
      * false to disable.
      */
     shouldFocusError?: boolean;
-}
-declare function Form<T extends Record<string, any> = any>({ form: f1, context, initialValues, values, onSubmit, onValidSubmit, onInvalidSubmit, shouldFocusError, ...props }: FormProps<T>): React.JSX.Element;
+};
+declare function Form<T extends Record<string, any> = any>({ form: f1, context, initialValues, values, shouldUnregister, validateOnMount, disabled, asyncAlways, onSubmit, onValidSubmit, onInvalidSubmit, action, shouldFocusError, ...props }: FormProps<T>): React.JSX.Element;
+
+/**
+ * Props for {@link FormField}: every {@link UseFieldOptions} option plus a
+ * render-prop `children` receiving the bound field result.
+ */
+type FormFieldProps<TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments> = UseFieldOptions$1<TValues, TPath> & {
+    children: (field: UseFieldResult<TValues, TPath>) => React.ReactNode;
+};
+/**
+ * Headless field bound through a render prop — the non-hook counterpart of
+ * {@link useField} for class components, callback-style consumers and
+ * library bridges where a hook cannot be called (Formik `<Field>` /
+ * TanStack `form.Field` shape).
+ *
+ * The child function receives the full {@link UseFieldResult} — value,
+ * error(s), onChange/onBlur, `disabled`, `focusRef`, the bound `form` —
+ * and renders whatever UI it wants; nothing is rendered when it returns
+ * null/undefined, so it can also gate conditional layout. Resolves its
+ * form from the module-level `FormContext` or the explicit `form` option
+ * (per-instance contexts from `createFormContext()` keep using their own
+ * `useField` hook).
+ */
+declare function FormField<TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments>({ children, ...options }: FormFieldProps<TValues, TPath>): React.ReactNode;
 
 /**
  * Props shared by Field/Checkbox/Select. Generic so a typed form flows into
@@ -477,7 +1409,7 @@ declare function Form<T extends Record<string, any> = any>({ form: f1, context,
  * bare `<Field name="x" />` (context-resolved, untyped) call sites exactly
  * as permissive as before.
  */
-interface UseFieldOptions<TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | Name = Name> {
+type UseFieldOptions<TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments> = {
     form?: Form$1<TValues>;
     name?: TPath;
     initialValue?: any;
@@ -496,10 +1428,17 @@ interface UseFieldOptions<TValues extends Record<string, any> = any, TPath exten
         signal: AbortSignal;
     }) => ReturnType<Validator>;
     /**
-     * Declarative rules (required/min/max/minLength/maxLength/pattern),
-     * compiled into a validator that runs before `validate`; failures land
-     * in the form's error state. Passed through to useField — like
-     * validateDebounce it is never spread onto the DOM element.
+     * Declarative rules (required/min/max/minLength/maxLength/pattern,
+     * plus custom `validate` callbacks), compiled into a validator that
+     * runs before `validate`; failures land in the form's error state.
+     * The declarative subset is also rendered as native constraint
+     * attributes (`required`, `minLength`, `pattern`, …) onto the element
+     * for browser/AT hints — `:invalid` styling, screen-reader
+     * announcements — while the store pipeline stays the source of truth
+     * for messages (`renderError`/`aria-invalid` keep working; a user-passed
+     * `required`/`pattern`/… prop overrides the derived attribute). Passed
+     * through to useField — like validateDebounce it is never spread onto
+     * the DOM element.
      */
     rules?: FieldRules;
     /**
@@ -509,6 +1448,21 @@ interface UseFieldOptions<TValues extends Record<string, any> = any, TPath exten
      * useField/useValidate.
      */
     validateDebounce?: number;
+    /**
+     * Run this field's debounced validator even when its `required` gate
+     * failed (TanStack Form's `asyncAlways`): the gate's errors land
+     * immediately, the validator's own result lands alongside them
+     * per-source. Falls back to the form-level `createForm({asyncAlways})`.
+     * Passed through to useField.
+     */
+    asyncAlways?: boolean;
+    /**
+     * Validate this field once on mount (see {@link
+     * UseFieldOptions}' `validateOnMount`): overrides the form-level
+     * `createForm({validateOnMount})` / `<Form validateOnMount>` flag in
+     * either direction. Passed through to useField.
+     */
+    validateOnMount?: boolean;
     /**
      * Disable this field's control: OR-ed with the form-level flag
      * (`createForm({disabled})` / `setDisabled`) — a field cannot opt out
@@ -532,9 +1486,19 @@ interface UseFieldOptions<TValues extends Record<string, any> = any, TPath exten
      * the DOM element.
      */
     mode?: ValidationMode;
+    /**
+     * Uncontrolled mode: render the element with `defaultValue` instead of
+     * `value` — typing re-renders nothing (the store still carries every
+     * write; errors/touched/disabled still re-render the field). The
+     * snapshot is pinned at mount; bulk operations (reset/setInitialValues)
+     * sync the DOM element directly without a render — RHF-register
+     * behavior (read live values with useValue/getValues). Passed through
+     * to useField, never spread onto the DOM element.
+     */
+    uncontrolled?: boolean;
     [key: string]: any;
-}
-interface FieldProps<TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | Name = Name> extends UseFieldOptions<TValues, TPath> {
+};
+type FieldProps<TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments> = UseFieldOptions<TValues, TPath> & {
     as?: React.ComponentType<any>;
     asProps?: Record<string, any>;
     eventToValue?: (e: any) => any;
@@ -549,7 +1513,23 @@ interface FieldProps<TValues extends Record<string, any> = any, TPath extends Fi
      * wiring for free.
      */
     renderError?: (error: string, id: string) => React.ReactNode;
-}
+    /**
+     * Store `e.target.valueAsNumber` instead of the string value —
+     * react-hook-form's `register({valueAsNumber})` counterpart for number
+     * inputs (`<input type="number">`). `NaN` passes through as-is when the
+     * input cannot be parsed, matching RHF. An explicit `eventToValue`
+     * takes precedence.
+     */
+    valueAsNumber?: boolean;
+    /**
+     * Store `e.target.valueAsDate` instead of the string value — RHF's
+     * `register({valueAsDate})` counterpart for date/time inputs. `null`
+     * passes through when the input cannot be parsed. An explicit
+     * `eventToValue` takes precedence; combining with `valueAsNumber` is a
+     * TypeError.
+     */
+    valueAsDate?: boolean;
+};
 /**
  * The error-message element id a field's `aria-describedby` points at —
  * `fieldErrorId('a[0].b')` is `'a-0-b'`, the same id `Field`'s built-in
@@ -568,32 +1548,31 @@ declare function fieldErrorId(name: Name): string;
  * same types, and the inline form trips no-use-before-define on the type
  * parameters.
  */
-interface FieldComponent {
-    <TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | Name = Name>(props: FieldProps<TValues, TPath> & React.RefAttributes<HTMLInputElement>): React.ReactElement | null;
-}
+type FieldComponent = {
+    <TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments>(props: FieldProps<TValues, TPath> & React.RefAttributes<HTMLInputElement>): React.ReactElement | null;
+};
 declare const Field: FieldComponent;
-interface CheckboxProps<TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | Name = Name> extends UseFieldOptions<TValues, TPath> {
-}
+type CheckboxProps<TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments> = UseFieldOptions<TValues, TPath>;
 /**
  * Callable shape of {@link Checkbox}: the same form-typed `validate`
  * inference contract as {@link FieldComponent}.
  */
-interface CheckboxComponent {
-    <TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | Name = Name>(props: CheckboxProps<TValues, TPath> & React.RefAttributes<HTMLInputElement>): React.ReactElement | null;
-}
+type CheckboxComponent = {
+    <TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments>(props: CheckboxProps<TValues, TPath> & React.RefAttributes<HTMLInputElement>): React.ReactElement | null;
+};
 declare const Checkbox: CheckboxComponent;
-interface SelectProps<TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | Name = Name> extends UseFieldOptions<TValues, TPath> {
+type SelectProps<TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments> = UseFieldOptions<TValues, TPath> & {
     multiple?: boolean;
     children?: React.ReactNode;
-}
+};
 /**
  * Callable shape of {@link Select}: the same form-typed `validate`
  * inference contract as {@link FieldComponent}.
  */
-interface SelectComponent {
-    <TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | Name = Name>(props: SelectProps<TValues, TPath> & React.RefAttributes<HTMLSelectElement>): React.ReactElement | null;
-}
+type SelectComponent = {
+    <TValues extends Record<string, any> = any, TPath extends FieldPath<TValues> | PathSegments = FieldPath<TValues> | PathSegments>(props: SelectProps<TValues, TPath> & React.RefAttributes<HTMLSelectElement>): React.ReactElement | null;
+};
 declare const Select: SelectComponent;
 
-export { Checkbox, CheckboxGroupContext, CheckboxGroupProvider, Field, FieldError, FieldPath, Form, FormContext, Form$1 as FormInstance, FormProvider, Name, Options, Path, PathValueOf, Select, ValidationMode, Validator, createFormContext, fieldErrorId, subscribe, useCanSubmit, useCheckboxGroupContext, useDirtyFields, useError, useErrorByPath, useField, useFieldArray, useFieldArrayItem, useFieldErrors, useFieldErrorsByPath, useForm, useFormContext, useHasErrors, useIsDirty, useIsSubmitting, useSubmitCount, useTouched, useTouchedByPath, useTouchedFields, useValue, useValueByPath, useWatch };
-export type { FieldRules, SubscribeEvent, SubscribeOptions, WatchScope };
+export { Checkbox, CheckboxGroupContext, CheckboxGroupProvider, Field, FieldError, FieldErrorEntry, FieldPath, Form, FormContext, FormEvents, FormField, Form$1 as FormInstance, FormProvider, Name, Options, Path, PathSegments, PathValueOf, Select, SyncValidator, ValidationMode, Validator, changeValue, changeValueByPath, createFormContext, emitChangeByPath, fieldErrorId, getDirtyFields, getFieldState, getTouchedFields, getValue, getValueByPath, getValues, handleSubmit, hasTouched, hasTouchedByPath, incrementSubmitCount, isDirty, isFieldDirtyByPath, isTouched, registerFieldMode, removeField, removeFieldByPath, reset, resetField, seedValueByPath, setDisabled, setInitialValues, setIsSubmitting, setStatus, setSubmitSuccessful, setTouched, setTouchedByPath, setValue, setValueByPath, subscribe, unregisterFieldMode, useCanSubmit, useCheckboxGroupContext, useDirtyFields, useError, useErrorByPath, useField, useFieldArray, useFieldArrayItem, useFieldErrors, useFieldErrorsByPath, useForm, useFormContext, useFormError, useFormErrors, useFormState, useHasErrors, useIsDirty, useIsFieldDirty, useIsFieldDirtyByPath, useIsLoading, useIsSubmitSuccessful, useIsSubmitting, useIsValid, useIsValidating, useStatus, useSubmitCount, useTouched, useTouchedByPath, useTouchedFields, useTransform, useValue, useValueByPath, useWatch, useWatchCore, userBlur, userChangeByPath };
+export type { FieldRules, FieldState, FormState, HandleSubmitOptions, RemoveFieldOptions, ResetFieldOptions, ResetOptions, SetFieldOptions, SubscribeEvent, SubscribeOptions, UseTransformOptions, UseValueOptions, WatchScope };