formstand 0.8.0 → 0.10.0

package/dist/index.d.cts

@@ -6,9 +6,41 @@ import { ReactNode, ChangeEvent } from 'react';
 type LeafType = string | number | boolean | bigint | symbol | null | undefined | Date | RegExp;
 type IsRecord<T> = T extends LeafType ? false : T extends readonly unknown[] ? false : T extends object ? true : false;
 type IsArray<T> = T extends readonly unknown[] ? true : false;
-type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8];
-type FieldPath<T, D extends number = 7> = [D] extends [0] ? never : IsArray<T> extends true ? T extends readonly (infer U)[] ? `${number}` | (IsRecord<NonNullable<U>> extends true ? `${number}.${FieldPath<NonNullable<U>, Prev[D]>}` : IsArray<NonNullable<U>> extends true ? `${number}.${FieldPath<NonNullable<U>, Prev[D]>}` : never) : never : IsRecord<T> extends true ? {
-    [K in keyof T & string]: K | (IsRecord<NonNullable<T[K]>> extends true ? `${K}.${FieldPath<NonNullable<T[K]>, Prev[D]>}` : IsArray<NonNullable<T[K]>> extends true ? `${K}.${FieldPath<NonNullable<T[K]>, Prev[D]>}` : never);
+type Prev = [
+    never,
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    16,
+    17,
+    18,
+    19,
+    20,
+    21,
+    22,
+    23,
+    24
+];
+type DefaultPathDepth = 9;
+type PathDepth = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25;
+type IsUnion<T, U = T> = [T] extends [never] ? false : T extends unknown ? [U] extends [T] ? false : true : never;
+type NormalizeDepth<D extends number> = number extends D ? DefaultPathDepth : [D] extends [PathDepth] ? IsUnion<D> extends true ? DefaultPathDepth : D : DefaultPathDepth;
+type FieldPath<T, D extends number = DefaultPathDepth> = FieldPathRec<T, NormalizeDepth<D>>;
+type FieldPathRec<T, D extends number> = [D] extends [0] ? never : IsArray<T> extends true ? T extends readonly (infer U)[] ? `${number}` | (IsRecord<NonNullable<U>> extends true ? `${number}.${FieldPathRec<NonNullable<U>, Prev[D]>}` : IsArray<NonNullable<U>> extends true ? `${number}.${FieldPathRec<NonNullable<U>, Prev[D]>}` : never) : never : IsRecord<T> extends true ? {
+    [K in keyof T & string]: K | (IsRecord<NonNullable<T[K]>> extends true ? `${K}.${FieldPathRec<NonNullable<T[K]>, Prev[D]>}` : IsArray<NonNullable<T[K]>> extends true ? `${K}.${FieldPathRec<NonNullable<T[K]>, Prev[D]>}` : never);
 }[keyof T & string] : never;
 type StepValue<T, K extends string> = T extends readonly (infer U)[] ? K extends `${number}` ? U : never : T extends object ? K extends keyof T ? T[K] : never : never;
 type FieldValue<T, P extends string> = [T] extends [NonNullable<T>] ? P extends `${infer Head}.${infer Tail}` ? FieldValue<StepValue<T, Head>, Tail> : StepValue<T, P> : FieldValue<NonNullable<T>, P> | undefined;
@@ -55,6 +87,16 @@ type FieldValidationResult = SettledFieldValidationResult | Readonly<{
     kind: "pending";
     promise: Promise<SettledFieldValidationResult>;
 }>;
+type SettledFieldsValidationResult = Readonly<{
+    kind: "valid";
+}> | Readonly<{
+    kind: "invalid";
+    errors: ErrorMap;
+}>;
+type FieldsValidationResult = SettledFieldsValidationResult | Readonly<{
+    kind: "pending";
+    promise: Promise<SettledFieldsValidationResult>;
+}>;
 declare const flattenIssues: (issues: readonly z.core.$ZodIssue[]) => ErrorMap;
 declare const validateSync: <TSchema extends z.ZodType>(schema: TSchema, values: z.input<TSchema>) => SettledValidationResult<z.output<TSchema>>;
 declare const validateAsync: <TSchema extends z.ZodType>(schema: TSchema, values: z.input<TSchema>) => Promise<SettledValidationResult<z.output<TSchema>>>;
@@ -62,11 +104,13 @@ declare const isAsyncRequiredError: (e: unknown) => boolean;
 declare const emptyValueForSchema: (schema: z.ZodType) => null | undefined;
 
 type ReadonlyStoreApi<T> = Pick<StoreApi<T>, "getState" | "getInitialState" | "subscribe">;
-type CreateFormOptions<TSchema extends z.ZodType> = Readonly<{
+type CreateFormOptions<TSchema extends z.ZodType, D extends PathDepth = DefaultPathDepth> = Readonly<{
     initialValues: z.input<TSchema>;
+    pathDepth?: D & (IsUnion<D> extends true ? never : unknown);
     mode?: ValidationMode;
     reValidateMode?: ValidationMode;
     validateOnMount?: boolean;
+    devtools?: boolean | string;
 }>;
 type SubmitHandler<TSchema extends z.ZodType> = (data: z.output<TSchema>) => void | Promise<void>;
 type InvalidSubmitHandler = (errors: ErrorMap) => void;
@@ -86,7 +130,7 @@ type SubmitResult<TOutput> = Readonly<{
     error: unknown;
 }>;
 type ArrayItemOf$1<T> = T extends readonly (infer U)[] ? U : never;
-type ErrorPath<TValues> = FieldPath<TValues> | "";
+type ErrorPath<TValues, D extends PathDepth = DefaultPathDepth> = FieldPath<TValues, D> | "";
 type ResetOptions = Readonly<{
     keepErrors?: boolean;
     keepTouched?: boolean;
@@ -99,41 +143,42 @@ type FieldSnapshot<TValue> = Readonly<{
     dirty: boolean;
     isValidating: boolean;
 }>;
-type Form<TSchema extends z.ZodType> = Readonly<{
+type Form<TSchema extends z.ZodType, D extends PathDepth = DefaultPathDepth> = Readonly<{
+    "~pathDepth"?: D;
     schema: TSchema;
     store: ReadonlyStoreApi<FormState<z.input<TSchema>>>;
     getState: () => FormState<z.input<TSchema>>;
     subscribe: (listener: (state: FormState<z.input<TSchema>>, prev: FormState<z.input<TSchema>>) => void) => () => void;
-    getField: <P extends FieldPath<z.input<TSchema>>>(path: P) => FieldValue<z.input<TSchema>, P>;
-    watchField: <P extends FieldPath<z.input<TSchema>>>(path: P, listener: (snapshot: FieldSnapshot<FieldValue<z.input<TSchema>, P>>) => void) => () => void;
-    watchValue: <P extends FieldPath<z.input<TSchema>>>(path: P, listener: (value: FieldValue<z.input<TSchema>, P>, previous: FieldValue<z.input<TSchema>, P>) => void) => () => void;
+    getField: <P extends FieldPath<z.input<TSchema>, D>>(path: P) => FieldValue<z.input<TSchema>, P>;
+    watchField: <P extends FieldPath<z.input<TSchema>, D>>(path: P, listener: (snapshot: FieldSnapshot<FieldValue<z.input<TSchema>, P>>) => void) => () => void;
+    watchValue: <P extends FieldPath<z.input<TSchema>, D>>(path: P, listener: (value: FieldValue<z.input<TSchema>, P>, previous: FieldValue<z.input<TSchema>, P>) => void) => () => void;
     watchValues: (listener: (values: z.input<TSchema>, previous: z.input<TSchema>) => void) => () => void;
-    setValue: <P extends FieldPath<z.input<TSchema>>>(path: P, value: FieldValue<z.input<TSchema>, P>) => void;
+    setValue: <P extends FieldPath<z.input<TSchema>, D>>(path: P, value: FieldValue<z.input<TSchema>, P>) => void;
     setValues: (next: z.input<TSchema>) => void;
-    setTouched: (path: FieldPath<z.input<TSchema>>, touched?: boolean) => void;
+    setTouched: (path: FieldPath<z.input<TSchema>, D>, touched?: boolean) => void;
     setSubmitting: (value: boolean) => void;
     setMode: (mode: ValidationMode) => void;
     setReValidateMode: (mode: ValidationMode) => void;
-    setError: (path: ErrorPath<z.input<TSchema>>, errors: string | readonly string[]) => void;
+    setError: (path: ErrorPath<z.input<TSchema>, D>, errors: string | readonly string[]) => void;
     setErrors: (errors: ErrorMap) => void;
-    clearErrors: (path?: ErrorPath<z.input<TSchema>>) => void;
+    clearErrors: (path?: ErrorPath<z.input<TSchema>, D>) => void;
     updateState: (updater: (state: FormState<z.input<TSchema>>) => Partial<Omit<FormState<z.input<TSchema>>, "errors">>) => void;
     reset: (nextInitial?: Partial<z.input<TSchema>>, options?: ResetOptions) => void;
-    resetField: (path: FieldPath<z.input<TSchema>>) => void;
+    resetField: (path: FieldPath<z.input<TSchema>, D>) => void;
     adoptValues: (values: z.input<TSchema>) => void;
-    getFieldState: <P extends FieldPath<z.input<TSchema>>>(path: P) => FieldSnapshot<FieldValue<z.input<TSchema>, P>>;
+    getFieldState: <P extends FieldPath<z.input<TSchema>, D>>(path: P) => FieldSnapshot<FieldValue<z.input<TSchema>, P>>;
     validate: () => ValidationResult<z.output<TSchema>>;
-    validateField: (path: ErrorPath<z.input<TSchema>>) => FieldValidationResult;
-    validateFields: (paths: readonly FieldPath<z.input<TSchema>>[]) => boolean | Promise<boolean>;
+    validateField: (path: ErrorPath<z.input<TSchema>, D>) => FieldValidationResult;
+    validateFields: (paths: readonly FieldPath<z.input<TSchema>, D>[]) => FieldsValidationResult;
     validateAsync: () => Promise<ValidationResult<z.output<TSchema>>>;
-    validateFieldAsync: (path: ErrorPath<z.input<TSchema>>) => Promise<FieldValidationResult>;
-    validateFieldsAsync: (paths: readonly FieldPath<z.input<TSchema>>[]) => Promise<boolean>;
+    validateFieldAsync: (path: ErrorPath<z.input<TSchema>, D>) => Promise<FieldValidationResult>;
+    validateFieldsAsync: (paths: readonly FieldPath<z.input<TSchema>, D>[]) => Promise<SettledFieldsValidationResult>;
     submit: (onValid: SubmitHandler<TSchema>, onInvalid?: InvalidSubmitHandler, options?: SubmitOptions) => Promise<SubmitResult<z.output<TSchema>>>;
-    arrayPush: <P extends FieldPath<z.input<TSchema>>>(path: P, item: ArrayItemOf$1<NonNullable<FieldValue<z.input<TSchema>, P>>>) => void;
-    arrayRemove: (path: FieldPath<z.input<TSchema>>, index: number) => void;
-    arrayInsert: <P extends FieldPath<z.input<TSchema>>>(path: P, index: number, item: ArrayItemOf$1<NonNullable<FieldValue<z.input<TSchema>, P>>>) => void;
-    arrayMove: (path: FieldPath<z.input<TSchema>>, from: number, to: number) => void;
-    arraySwap: (path: FieldPath<z.input<TSchema>>, a: number, b: number) => void;
+    arrayPush: <P extends FieldPath<z.input<TSchema>, D>>(path: P, item: ArrayItemOf$1<NonNullable<FieldValue<z.input<TSchema>, P>>>) => void;
+    arrayRemove: (path: FieldPath<z.input<TSchema>, D>, index: number) => void;
+    arrayInsert: <P extends FieldPath<z.input<TSchema>, D>>(path: P, index: number, item: ArrayItemOf$1<NonNullable<FieldValue<z.input<TSchema>, P>>>) => void;
+    arrayMove: (path: FieldPath<z.input<TSchema>, D>, from: number, to: number) => void;
+    arraySwap: (path: FieldPath<z.input<TSchema>, D>, a: number, b: number) => void;
     handleSubmit: (onValid: SubmitHandler<TSchema>, onInvalid?: InvalidSubmitHandler, options?: SubmitOptions) => (event?: {
         preventDefault: () => void;
     }) => Promise<SubmitResult<z.output<TSchema>>>;
@@ -142,24 +187,42 @@ type Form<TSchema extends z.ZodType> = Readonly<{
     snapshot: () => FormState<z.input<TSchema>>;
     restore: (snapshot: FormState<z.input<TSchema>>) => void;
 }>;
-declare const createForm: <TSchema extends z.ZodType>(schema: TSchema, options: CreateFormOptions<TSchema>) => Form<TSchema>;
+declare const createForm: <TSchema extends z.ZodType, D extends PathDepth = DefaultPathDepth>(schema: TSchema, options: CreateFormOptions<TSchema, D>) => Form<TSchema, D>;
 
 type PathSegment = string | number;
 declare const parsePath: (path: string) => readonly PathSegment[];
 declare const getAtPath: (obj: unknown, path: string) => unknown;
 declare const setAtPath: <T>(obj: T, path: string, value: unknown) => T;
 
-declare const useForm: <TSchema extends z.ZodType>(schema: TSchema, options: CreateFormOptions<TSchema>) => Form<TSchema>;
+type PersistStorage = Readonly<{
+    getItem: (key: string) => string | null;
+    setItem: (key: string, value: string) => void;
+    removeItem: (key: string) => void;
+}>;
+type PersistOptions<TSchema extends z.ZodType> = Readonly<{
+    key: string;
+    storage?: PersistStorage;
+    debounceMs?: number;
+    apply?: "adopt" | "restore" | "manual";
+}>;
+type PersistHandle = Readonly<{
+    restore: () => boolean;
+    clear: () => void;
+    dispose: () => void;
+}>;
+declare const persistForm: <TSchema extends z.ZodType, D extends PathDepth = DefaultPathDepth>(form: Form<TSchema, D>, options: PersistOptions<TSchema>) => PersistHandle;
 
-type FormProviderProps<TSchema extends z.ZodType> = Readonly<{
-    form: Form<TSchema>;
+declare const useForm: <TSchema extends z.ZodType, D extends PathDepth = DefaultPathDepth>(schema: TSchema, options: CreateFormOptions<TSchema, D>) => Form<TSchema, D>;
+
+type FormProviderProps<TSchema extends z.ZodType, D extends PathDepth = DefaultPathDepth> = Readonly<{
+    form: Form<TSchema, D>;
     children: ReactNode;
 }>;
-type FormContextApi<TSchema extends z.ZodType> = Readonly<{
-    Provider: (props: FormProviderProps<TSchema>) => ReactNode;
-    useFormContext: () => Form<TSchema>;
+type FormContextApi<TSchema extends z.ZodType, D extends PathDepth = DefaultPathDepth> = Readonly<{
+    Provider: (props: FormProviderProps<TSchema, D>) => ReactNode;
+    useFormContext: () => Form<TSchema, D>;
 }>;
-declare const createFormContext: <TSchema extends z.ZodType>() => FormContextApi<TSchema>;
+declare const createFormContext: <TSchema extends z.ZodType, D extends PathDepth = DefaultPathDepth>() => FormContextApi<TSchema, D>;
 
 type ReadonlyStore$2<T> = Pick<StoreApi<T>, "getState" | "getInitialState" | "subscribe">;
 type FieldFormApi = Readonly<{
@@ -192,11 +255,24 @@ type UseFieldReturn<TValue> = Readonly<{
     validateAsync: () => Promise<FieldValidationResult>;
     onBlur: () => void;
 }>;
-declare function useField<TSchema extends z.ZodType>(form: Form<TSchema>, pathSelector: (state: FormState<z.input<TSchema>>) => string, options?: UseFieldOptions): UseFieldReturn<unknown>;
+declare function useField<TSchema extends z.ZodType>(form: FieldFormApi & Readonly<{
+    schema: TSchema;
+    store: ReadonlyStore$2<FormState<z.input<TSchema>>>;
+}>, pathSelector: (state: FormState<z.input<TSchema>>) => string, options?: UseFieldOptions): UseFieldReturn<unknown>;
 declare function useField<TValue = unknown>(form: FieldFormApi & {
     readonly schema?: undefined;
-}, path: string | ((state: FormState<unknown>) => string), options?: UseFieldOptions): UseFieldReturn<TValue>;
-declare function useField<TSchema extends z.ZodType, P extends FieldPath<z.input<TSchema>>>(form: Form<TSchema>, path: P, options?: UseFieldOptions): UseFieldReturn<FieldValue<z.input<TSchema>, P>>;
+}, path: FieldPathArg<unknown>, options?: UseFieldOptions): UseFieldReturn<TValue>;
+declare function useField<TSchema extends z.ZodType, P extends FieldPath<z.input<TSchema>, D>, D extends PathDepth = DefaultPathDepth>(form: Form<TSchema, D>, path: P, options?: UseFieldOptions): UseFieldReturn<FieldValue<z.input<TSchema>, P>>;
+
+type VariantFieldValue<V, TField extends string> = V extends unknown ? TField extends keyof V ? V[TField] : never : never;
+type CommonKeys<V> = keyof V;
+type AllKeys<V> = V extends unknown ? keyof V : never;
+type VariantKeys<V> = Exclude<AllKeys<V>, CommonKeys<V>> & string;
+type UnionValueAt<TValues, P extends string> = P extends keyof TValues ? NonNullable<TValues[P]> : P extends `${infer Head}.${infer Tail}` ? Head extends keyof TValues ? UnionValueAt<NonNullable<TValues[Head]>, Tail> : never : never;
+declare function useVariantField<TSchema extends z.ZodType, P extends string, TField extends VariantKeys<UnionValueAt<z.input<TSchema>, P>>, D extends PathDepth = DefaultPathDepth>(form: Form<TSchema, D>, unionPath: P, field: TField): UseFieldReturn<VariantFieldValue<UnionValueAt<z.input<TSchema>, P>, TField> | undefined>;
+declare function useVariantField<TValue = unknown>(form: FieldFormApi & {
+    readonly schema?: undefined;
+}, unionPath: string, field: string): UseFieldReturn<TValue | undefined>;
 
 type ReadonlyStore$1<T> = Pick<StoreApi<T>, "getState" | "getInitialState" | "subscribe">;
 type FieldArrayFormApi = Readonly<{
@@ -223,26 +299,32 @@ type UseFieldArrayReturn<TItem> = Readonly<{
     swap: (a: number, b: number) => void;
 }>;
 type ArrayItemOf<T> = [NonNullable<T>] extends [readonly (infer U)[]] ? U : never;
-declare function useFieldArray<TSchema extends z.ZodType>(form: Form<TSchema>, pathSelector: (state: FormState<z.input<TSchema>>) => string): UseFieldArrayReturn<unknown>;
+declare function useFieldArray<TSchema extends z.ZodType>(form: FieldArrayFormApi & Readonly<{
+    schema: TSchema;
+    store: ReadonlyStore$1<FormState<z.input<TSchema>>>;
+}>, pathSelector: (state: FormState<z.input<TSchema>>) => string): UseFieldArrayReturn<unknown>;
 declare function useFieldArray<TItem = unknown>(form: FieldArrayFormApi & {
     readonly schema?: undefined;
-}, path: string | ((state: FormState<unknown>) => string)): UseFieldArrayReturn<TItem>;
-declare function useFieldArray<TSchema extends z.ZodType, P extends FieldPath<z.input<TSchema>>>(form: Form<TSchema>, path: P): UseFieldArrayReturn<ArrayItemOf<FieldValue<z.input<TSchema>, P>>>;
+}, path: FieldPathArg<unknown>): UseFieldArrayReturn<TItem>;
+declare function useFieldArray<TSchema extends z.ZodType, P extends FieldPath<z.input<TSchema>, D>, D extends PathDepth = DefaultPathDepth>(form: Form<TSchema, D>, path: P): UseFieldArrayReturn<ArrayItemOf<FieldValue<z.input<TSchema>, P>>>;
 
-type BoundUseField<TSchema extends z.ZodType> = {
+type BoundUseField<TSchema extends z.ZodType, D extends PathDepth = DefaultPathDepth> = {
     (pathSelector: (state: FormState<z.input<TSchema>>) => string, options?: UseFieldOptions): UseFieldReturn<unknown>;
-    <P extends FieldPath<z.input<TSchema>>>(path: P, options?: UseFieldOptions): UseFieldReturn<FieldValue<z.input<TSchema>, P>>;
+    <P extends FieldPath<z.input<TSchema>, D>>(path: P, options?: UseFieldOptions): UseFieldReturn<FieldValue<z.input<TSchema>, P>>;
 };
-type BoundUseFieldArray<TSchema extends z.ZodType> = {
+type BoundUseVariantField<TSchema extends z.ZodType> = <P extends string, TField extends VariantKeys<UnionValueAt<z.input<TSchema>, P>>>(unionPath: P, field: TField) => UseFieldReturn<VariantFieldValue<UnionValueAt<z.input<TSchema>, P>, TField> | undefined>;
+type BoundUseFieldArray<TSchema extends z.ZodType, D extends PathDepth = DefaultPathDepth> = {
     (pathSelector: (state: FormState<z.input<TSchema>>) => string): UseFieldArrayReturn<unknown>;
-    <P extends FieldPath<z.input<TSchema>>>(path: P): UseFieldArrayReturn<ArrayItemOf<FieldValue<z.input<TSchema>, P>>>;
+    <P extends FieldPath<z.input<TSchema>, D>>(path: P): UseFieldArrayReturn<ArrayItemOf<FieldValue<z.input<TSchema>, P>>>;
 };
 type BoundUseSelector<TSchema extends z.ZodType> = <U>(selector: (state: FormState<z.input<TSchema>>) => U) => U;
-type BoundUseFlag<TSchema extends z.ZodType> = (path?: FieldPath<z.input<TSchema>>) => boolean;
-type FormHooks<TSchema extends z.ZodType, N extends string> = Readonly<{
-    [K in `use${Capitalize<N>}Field`]: BoundUseField<TSchema>;
+type BoundUseFlag<TSchema extends z.ZodType, D extends PathDepth = DefaultPathDepth> = (path?: FieldPath<z.input<TSchema>, D>) => boolean;
+type FormHooks<TSchema extends z.ZodType, N extends string, D extends PathDepth = DefaultPathDepth> = Readonly<{
+    [K in `use${Capitalize<N>}Field`]: BoundUseField<TSchema, D>;
+} & {
+    [K in `use${Capitalize<N>}VariantField`]: BoundUseVariantField<TSchema>;
 } & {
-    [K in `use${Capitalize<N>}FieldArray`]: BoundUseFieldArray<TSchema>;
+    [K in `use${Capitalize<N>}FieldArray`]: BoundUseFieldArray<TSchema, D>;
 } & {
     [K in `use${Capitalize<N>}Selector`]: BoundUseSelector<TSchema>;
 } & {
@@ -250,25 +332,25 @@ type FormHooks<TSchema extends z.ZodType, N extends string> = Readonly<{
 } & {
     [K in `use${Capitalize<N>}Error`]: () => readonly string[] | undefined;
 } & {
-    [K in `use${Capitalize<N>}IsDirty`]: BoundUseFlag<TSchema>;
+    [K in `use${Capitalize<N>}IsDirty`]: BoundUseFlag<TSchema, D>;
 } & {
-    [K in `use${Capitalize<N>}IsValid`]: BoundUseFlag<TSchema>;
+    [K in `use${Capitalize<N>}IsValid`]: BoundUseFlag<TSchema, D>;
 } & {
     [K in `use${Capitalize<N>}IsSubmitting`]: () => boolean;
 } & {
     [K in `use${Capitalize<N>}SubmitCount`]: () => number;
 }>;
-declare const createFormHooks: <TSchema extends z.ZodType, N extends string = "">(form: Form<TSchema>, name?: N) => FormHooks<TSchema, N>;
+declare const createFormHooks: <TSchema extends z.ZodType, N extends string = "", D extends PathDepth = DefaultPathDepth>(form: Form<TSchema, D>, name?: N) => FormHooks<TSchema, N, D>;
 
 type ReadonlyStore<T> = Pick<StoreApi<T>, "getState" | "getInitialState" | "subscribe">;
 type FormStateApi = Readonly<{
     store: ReadonlyStore<FormState<unknown>>;
 }>;
-declare function useFormSelector<TSchema extends z.ZodType, U>(form: Form<TSchema>, selector: (state: FormState<z.input<TSchema>>) => U): U;
+declare function useFormSelector<TSchema extends z.ZodType, U, D extends PathDepth = DefaultPathDepth>(form: Form<TSchema, D>, selector: (state: FormState<z.input<TSchema>>) => U): U;
 declare function useFormSelector<U>(form: FormStateApi & {
     readonly schema?: undefined;
 }, selector: (state: FormState<unknown>) => U): U;
-declare function useFormSelectorShallow<TSchema extends z.ZodType, U>(form: Form<TSchema>, selector: (state: FormState<z.input<TSchema>>) => U): U;
+declare function useFormSelectorShallow<TSchema extends z.ZodType, U, D extends PathDepth = DefaultPathDepth>(form: Form<TSchema, D>, selector: (state: FormState<z.input<TSchema>>) => U): U;
 declare function useFormSelectorShallow<U>(form: FormStateApi & {
     readonly schema?: undefined;
 }, selector: (state: FormState<unknown>) => U): U;
@@ -278,15 +360,15 @@ declare const useFormError: (form: FormStateApi) => readonly string[] | undefine
 declare function useIsDirty(form: FormStateApi & {
     readonly schema?: undefined;
 }, path?: string): boolean;
-declare function useIsDirty<TSchema extends z.ZodType, P extends FieldPath<z.input<TSchema>>>(form: Form<TSchema>, path?: P): boolean;
+declare function useIsDirty<TSchema extends z.ZodType, P extends FieldPath<z.input<TSchema>, D>, D extends PathDepth = DefaultPathDepth>(form: Form<TSchema, D>, path?: P): boolean;
 declare function useIsValid(form: FormStateApi & {
     readonly schema?: undefined;
 }, path?: string): boolean;
-declare function useIsValid<TSchema extends z.ZodType, P extends FieldPath<z.input<TSchema>>>(form: Form<TSchema>, path?: P): boolean;
+declare function useIsValid<TSchema extends z.ZodType, P extends FieldPath<z.input<TSchema>, D>, D extends PathDepth = DefaultPathDepth>(form: Form<TSchema, D>, path?: P): boolean;
 declare const useIsSubmitting: (form: FormStateApi) => boolean;
 declare const useSubmitCount: (form: FormStateApi) => number;
 
-type PathsOf<F extends FieldFormApi> = F extends Form<infer TSchema extends z.ZodType> ? FieldPath<z.input<TSchema>> : string;
+type PathsOf<F extends FieldFormApi> = F extends Form<infer TSchema extends z.ZodType, infer D extends PathDepth> ? FieldPath<z.input<TSchema>, D> : string;
 type FieldRef<T> = ((instance: T | null) => void) | Readonly<{
     current: T | null;
 }> | null;
@@ -300,6 +382,15 @@ type TextFieldProps<F extends FieldFormApi = FieldFormApi> = Readonly<{
     ref?: FieldRef<HTMLInputElement>;
 }>;
 declare const TextField: <F extends FieldFormApi>({ form, path, label, placeholder, type, autoComplete, ref, }: TextFieldProps<F>) => react.JSX.Element;
+type DateFieldProps<F extends FieldFormApi = FieldFormApi> = Readonly<{
+    form: F;
+    path: PathsOf<F>;
+    label?: ReactNode;
+    min?: string;
+    max?: string;
+    ref?: FieldRef<HTMLInputElement>;
+}>;
+declare const DateField: <F extends FieldFormApi>({ form, path, label, min, max, ref, }: DateFieldProps<F>) => react.JSX.Element;
 type NumberFieldProps<F extends FieldFormApi = FieldFormApi> = Readonly<{
     form: F;
     path: PathsOf<F>;
@@ -347,6 +438,14 @@ type NumberInputProps = Readonly<{
     onChange: (e: ChangeEvent<HTMLInputElement>) => void;
     onBlur: () => void;
 }>;
+type DateInputProps = Readonly<{
+    type: "date";
+    name: string;
+    value: string;
+    "aria-invalid": true | undefined;
+    onChange: (e: ChangeEvent<HTMLInputElement>) => void;
+    onBlur: () => void;
+}>;
 type CheckboxProps = Readonly<{
     type: "checkbox";
     name: string;
@@ -362,6 +461,7 @@ type SelectProps = Readonly<{
     onChange: (e: ChangeEvent<HTMLSelectElement>) => void;
     onBlur: () => void;
 }>;
+declare const hasFieldError: (error: readonly string[] | undefined) => boolean;
 declare const numberToInputText: (value: number | null | undefined) => string;
 type ParsedNumberText = Readonly<{
     kind: "empty";
@@ -374,7 +474,18 @@ type ParsedNumberText = Readonly<{
 declare const parseNumberText: (text: string) => ParsedNumberText;
 declare const textInputProps: <T extends string | null | undefined>(field: UseFieldReturn<T>) => TextInputProps;
 declare const numberInputProps: <T extends number | null | undefined>(field: UseFieldReturn<T>) => NumberInputProps;
+declare const dateToInputText: (value: Date | null | undefined) => string;
+type ParsedDateText = Readonly<{
+    kind: "empty";
+}> | Readonly<{
+    kind: "date";
+    value: Date;
+}> | Readonly<{
+    kind: "invalid";
+}>;
+declare const parseDateText: (text: string) => ParsedDateText;
+declare const dateInputProps: <T extends Date | null | undefined>(field: UseFieldReturn<T>) => DateInputProps;
 declare const checkboxProps: <T extends boolean | null | undefined>(field: UseFieldReturn<T>) => CheckboxProps;
 declare const selectProps: <T extends string | null | undefined>(field: UseFieldReturn<T>) => SelectProps;
 
-export { type BoolMap, type BoundUseField, type BoundUseFieldArray, type BoundUseFlag, type BoundUseSelector, CheckboxField, type CheckboxFieldProps, type CheckboxProps, type CreateFormOptions, type ErrorMap, type FieldArrayEntry, type FieldArrayFormApi, type FieldFormApi, type FieldPath, type FieldPathArg, type FieldRef, type FieldSnapshot, type FieldValidationResult, type FieldValue, type Form, type FormContextApi, type FormHooks, type FormProviderProps, type FormState, type FormStateApi, type InvalidSubmitHandler, NumberField, type NumberFieldProps, type NumberInputProps, type ParsedNumberText, type PathSegment, type PathsOf, type ReadonlyStoreApi, type ResetOptions, SelectField, type SelectFieldOption, type SelectFieldProps, type SelectProps, type SettledFieldValidationResult, type SettledValidationResult, type SubmitHandler, type SubmitOptions, type SubmitResult, TextField, type TextFieldProps, type TextInputProps, type UseFieldArrayReturn, type UseFieldOptions, type UseFieldReturn, type ValidationMode, type ValidationResult, type ValidationTrigger, checkboxProps, createForm, createFormContext, createFormHooks, emptyValueForSchema, flattenIssues, focusField, focusFirstError, getAtPath, isAsyncRequiredError, numberInputProps, numberToInputText, parseNumberText, parsePath, selectProps, setAtPath, shouldValidateOn, textInputProps, useField, useFieldArray, useForm, useFormError, useFormSelector, useFormSelectorShallow, useIsDirty, useIsSubmitting, useIsValid, useSubmitCount, validateAsync, validateSync };
+export { type BoolMap, type BoundUseField, type BoundUseFieldArray, type BoundUseFlag, type BoundUseSelector, CheckboxField, type CheckboxFieldProps, type CheckboxProps, type CreateFormOptions, DateField, type DateFieldProps, type DateInputProps, type DefaultPathDepth, type ErrorMap, type FieldArrayEntry, type FieldArrayFormApi, type FieldFormApi, type FieldPath, type FieldPathArg, type FieldRef, type FieldSnapshot, type FieldValidationResult, type FieldValue, type FieldsValidationResult, type Form, type FormContextApi, type FormHooks, type FormProviderProps, type FormState, type FormStateApi, type InvalidSubmitHandler, NumberField, type NumberFieldProps, type NumberInputProps, type ParsedDateText, type ParsedNumberText, type PathDepth, type PathSegment, type PathsOf, type PersistHandle, type PersistOptions, type PersistStorage, type ReadonlyStoreApi, type ResetOptions, SelectField, type SelectFieldOption, type SelectFieldProps, type SelectProps, type SettledFieldValidationResult, type SettledFieldsValidationResult, type SettledValidationResult, type SubmitHandler, type SubmitOptions, type SubmitResult, TextField, type TextFieldProps, type TextInputProps, type UseFieldArrayReturn, type UseFieldOptions, type UseFieldReturn, type ValidationMode, type ValidationResult, type ValidationTrigger, checkboxProps, createForm, createFormContext, createFormHooks, dateInputProps, dateToInputText, emptyValueForSchema, flattenIssues, focusField, focusFirstError, getAtPath, hasFieldError, isAsyncRequiredError, numberInputProps, numberToInputText, parseDateText, parseNumberText, parsePath, persistForm, selectProps, setAtPath, shouldValidateOn, textInputProps, useField, useFieldArray, useForm, useFormError, useFormSelector, useFormSelectorShallow, useIsDirty, useIsSubmitting, useIsValid, useSubmitCount, useVariantField, validateAsync, validateSync };