react-f0rm 1.1.1 → 1.3.0

package/dist/form-CeKSBs31.d.ts

@@ -0,0 +1,486 @@
+import { EventEmitter } from '@for-fun/event-emitter';
+
+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;
+/** 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 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`.
+ * @example FieldPath<{a: {b: string}}> // 'a' | 'a.b' | 'a[b]'
+ */
+type FieldPath<T> = IsAny<T> extends true ? string : 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;
+
+/** 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[];
+/**
+ * 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;
+/**
+ * Set field touched state
+ * @param form
+ * @param name
+ */
+/**
+ * @param form
+ */
+declare function hasErrors({ errors }: Form): boolean;
+
+/** 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';
+/** 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', []] | ['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>;
+    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;
+    /**
+     * 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;
+};
+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.
+     */
+    validate?: FormValidateFn<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>[];
+    /**
+     * 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;
+    /**
+     * 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 { setFocus as A, setServerErrors as B, FORM_ERROR as g, VALIDATION_OUTCOME as m, clearErrors as p, create as q, getError as r, getErrorByPath as s, getErrors as t, getFieldErrors as u, getFieldErrorsByPath as v, getFirstError as w, hasErrors as x, setError as y, setErrorByPath as z };
+export type { Form as F, Name as N, Options as O, Path as P, ReValidateMode as R, SetErrorOptions as S, ValidationMode as V, FieldError as a, FieldPath as b, PathSegments as c, PathValueOf as d, FieldErrorEntry as e, FormEvents as f, FormValidateFn as h, FormValidateMeta as i, PathValue as j, SetFocusOptions as k, SetServerErrorsOptions as l, ValidateResult as n, ValidationOutcome as o };