vee-validate 4.8.6 → 4.9.0

package/README.md

@@ -168,6 +168,7 @@ You are welcome to contribute to this project, but before you do, please make su
 
 - Inspired by Laravel's [validation syntax](https://laravel.com/docs/5.4/validation)
 - v4 API Inspired by [Formik's](https://github.com/formium/formik)
+- Nested path types by [react-hook-form](https://github.com/react-hook-form/react-hook-form)
 - Logo by [Baianat](https://github.com/baianat)
 
 ## Emeriti

package/dist/vee-validate.d.ts

@@ -1,5 +1,141 @@
 import * as vue from 'vue';
 import { Ref, ComputedRef, PropType, VNode, UnwrapRef, InjectionKey } from 'vue';
+import { PartialDeep } from 'type-fest';
+
+type BrowserNativeObject = Date | FileList | File;
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+/**
+ * Checks whether the type is any
+ * See {@link https://stackoverflow.com/a/49928360/3406963}
+ * @typeParam T - type which may be any
+ * ```
+ * IsAny<any> = true
+ * IsAny<string> = false
+ * ```
+ */
+type IsAny<T> = 0 extends 1 & T ? true : false;
+/**
+ * Checks whether T1 can be exactly (mutually) assigned to T2
+ * @typeParam T1 - type to check
+ * @typeParam T2 - type to check against
+ * ```
+ * IsEqual<string, string> = true
+ * IsEqual<'foo', 'foo'> = true
+ * IsEqual<string, number> = false
+ * IsEqual<string, number> = false
+ * IsEqual<string, 'foo'> = false
+ * IsEqual<'foo', string> = false
+ * IsEqual<'foo' | 'bar', 'foo'> = boolean // 'foo' is assignable, but 'bar' is not (true | false) -> boolean
+ * ```
+ */
+type IsEqual<T1, T2> = T1 extends T2 ? (<G>() => G extends T1 ? 1 : 2) extends <G>() => G extends T2 ? 1 : 2 ? true : false : false;
+/**
+ * Type to query whether an array type T is a tuple type.
+ * @typeParam T - type which may be an array or tuple
+ * @example
+ * ```
+ * IsTuple<[number]> = true
+ * IsTuple<number[]> = false
+ * ```
+ */
+type IsTuple<T extends ReadonlyArray<any>> = number extends T['length'] ? false : true;
+/**
+ * Type which can be used to index an array or tuple type.
+ */
+type ArrayKey = number;
+/**
+ * Helper function to break apart T1 and check if any are equal to T2
+ *
+ * See {@link IsEqual}
+ */
+type AnyIsEqual<T1, T2> = T1 extends T2 ? (IsEqual<T1, T2> extends true ? true : never) : never;
+/**
+ * Type which given a tuple type returns its own keys, i.e. only its indices.
+ * @typeParam T - tuple type
+ * @example
+ * ```
+ * TupleKeys<[number, string]> = '0' | '1'
+ * ```
+ */
+type TupleKeys<T extends ReadonlyArray<any>> = Exclude<keyof T, keyof any[]>;
+/**
+ * Helper type for recursively constructing paths through a type.
+ * This actually constructs the strings and recurses into nested
+ * object types.
+ *
+ * See {@link Path}
+ */
+type PathImpl<K extends string | number, V, TraversedTypes> = V extends Primitive | BrowserNativeObject ? `${K}` : true extends AnyIsEqual<TraversedTypes, V> ? `${K}` : `${K}` | `${K}.${PathInternal<V, TraversedTypes | V>}`;
+/**
+ * Helper type for recursively constructing paths through a type.
+ * This obscures the internal type param TraversedTypes from ed contract.
+ *
+ * See {@link Path}
+ */
+type PathInternal<T, TraversedTypes = T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? {
+    [K in TupleKeys<T>]-?: PathImpl<K & string, T[K], TraversedTypes>;
+}[TupleKeys<T>] : PathImpl<ArrayKey, V, TraversedTypes> : {
+    [K in keyof T]-?: PathImpl<K & string, T[K], TraversedTypes>;
+}[keyof T];
+/**
+ * Helper type for recursively constructing paths through a type.
+ * This actually constructs the strings and recurses into nested
+ * object types.
+ *
+ * See {@link ArrayPath}
+ */
+type ArrayPathImpl<K extends string | number, V, TraversedTypes> = V extends Primitive | BrowserNativeObject ? IsAny<V> extends true ? string : never : V extends ReadonlyArray<infer U> ? U extends Primitive | BrowserNativeObject ? IsAny<V> extends true ? string : never : true extends AnyIsEqual<TraversedTypes, V> ? never : `${K}` | `${K}.${ArrayPathInternal<V, TraversedTypes | V>}` : true extends AnyIsEqual<TraversedTypes, V> ? never : `${K}.${ArrayPathInternal<V, TraversedTypes | V>}`;
+/**
+ * Helper type for recursively constructing paths through a type.
+ * This obscures the internal type param TraversedTypes from ed contract.
+ *
+ * See {@link ArrayPath}
+ */
+type ArrayPathInternal<T, TraversedTypes = T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? {
+    [K in TupleKeys<T>]-?: ArrayPathImpl<K & string, T[K], TraversedTypes>;
+}[TupleKeys<T>] : ArrayPathImpl<ArrayKey, V, TraversedTypes> : {
+    [K in keyof T]-?: ArrayPathImpl<K & string, T[K], TraversedTypes>;
+}[keyof T];
+/**
+ * Type which eagerly collects all paths through a type which point to an array
+ * type.
+ * @typeParam T - type which should be introspected.
+ * @example
+ * ```
+ * Path<{foo: {bar: string[], baz: number[]}}> = 'foo.bar' | 'foo.baz'
+ * ```
+ */
+type ArrayPath<T> = T extends any ? ArrayPathInternal<T> : never;
+/**
+ * Type to evaluate the type which the given path points to.
+ * @typeParam T - deeply nested type which is indexed by the path
+ * @typeParam P - path into the deeply nested type
+ * @example
+ * ```
+ * PathValue<{foo: {bar: string}}, 'foo.bar'> = string
+ * PathValue<[number, string], '1'> = string
+ * ```
+ */
+type PathValue<T, P extends Path<T> | ArrayPath<T>> = T extends any ? P extends `${infer K}.${infer R}` ? K extends keyof T ? R extends Path<T[K]> ? PathValue<T[K], R> : never : K extends `${ArrayKey}` ? T extends ReadonlyArray<infer V> ? PathValue<V, R & Path<V>> : never : never : P extends keyof T ? T[P] : P extends `${ArrayKey}` ? T extends ReadonlyArray<infer V> ? V : never : never : never;
+/**
+ * Type which eagerly collects all paths through a type
+ * @typeParam T - type which should be introspected
+ * @example
+ * ```
+ * Path<{foo: {bar: string}}> = 'foo' | 'foo.bar'
+ * ```
+ */
+type Path<T> = T extends any ? PathInternal<T> : never;
+
+type GenericObject = Record<string, any>;
+type MaybeRef<T> = Ref<T> | T;
+type MaybeRefOrLazy<T> = MaybeRef<T> | (() => T);
+type MapValuesPathsToRefs<TValues extends GenericObject, TPaths extends readonly [...MaybeRef<Path<TValues>>[]]> = {
+    readonly [K in keyof TPaths]: TPaths[K] extends MaybeRef<infer TKey> ? TKey extends Path<TValues> ? Ref<PathValue<TValues, TKey>> : Ref<unknown> : Ref<unknown>;
+};
+type FlattenAndSetPathsType<TRecord, TType> = {
+    [K in Path<TRecord>]: TType;
+};
 
 interface FieldValidationMetaInfo {
     field: string;
@@ -16,7 +152,6 @@ type ValidationRuleFunction<TValue = unknown, TParams = unknown[] | Record<strin
 type SimpleValidationRuleFunction<TValue = unknown, TParams = unknown[] | Record<string, unknown>> = (value: TValue, params: TParams) => boolean | string | Promise<boolean | string>;
 type ValidationMessageGenerator = (ctx: FieldValidationMetaInfo) => string;
 
-type GenericFormValues = Record<string, any>;
 interface ValidationResult {
     errors: string[];
     valid: boolean;
@@ -35,10 +170,8 @@ interface TypedSchema<TInput = any, TOutput = TInput> {
 }
 type YupSchema<TValues = any> = {
     __isYupSchema__: boolean;
-    validate(value: any, options: Record<string, any>): Promise<any>;
+    validate(value: any, options: GenericObject): Promise<any>;
 };
-type MaybeRef<T> = Ref<T> | T;
-type MaybeRefOrLazy<T> = MaybeRef<T> | (() => T);
 interface FieldMeta<TValue> {
     touched: boolean;
     dirty: boolean;
@@ -47,7 +180,7 @@ interface FieldMeta<TValue> {
     pending: boolean;
     initialValue?: TValue;
 }
-interface FormMeta<TValues extends Record<string, any>> {
+interface FormMeta<TValues extends GenericObject> {
     touched: boolean;
     dirty: boolean;
     valid: boolean;
@@ -60,6 +193,7 @@ interface FieldState<TValue = unknown> {
     touched: boolean;
     errors: string[];
 }
+type InputType = 'checkbox' | 'radio' | 'default';
 /**
  * validated-only: only mutate the previously validated fields
  * silent: do not mutate any field
@@ -69,6 +203,31 @@ type SchemaValidationMode = 'validated-only' | 'silent' | 'force';
 interface ValidationOptions$1 {
     mode: SchemaValidationMode;
 }
+type FieldValidator = (opts?: Partial<ValidationOptions$1>) => Promise<ValidationResult>;
+interface PathStateConfig {
+    bails: boolean;
+    label: MaybeRef<string | undefined>;
+    type: InputType;
+    validate: FieldValidator;
+}
+interface PathState<TValue = unknown> {
+    id: number | number[];
+    path: string;
+    touched: boolean;
+    dirty: boolean;
+    valid: boolean;
+    validated: boolean;
+    pending: boolean;
+    initialValue: TValue | undefined;
+    value: TValue | undefined;
+    errors: string[];
+    bails: boolean;
+    label: string | undefined;
+    type: InputType;
+    multiple: boolean;
+    fieldsCount: number;
+    validate?: FieldValidator;
+}
 interface FieldEntry<TValue = unknown> {
     value: TValue;
     key: string | number;
@@ -106,7 +265,7 @@ interface PrivateFieldContext<TValue = unknown> {
     checked?: Ref<boolean>;
     resetField(state?: Partial<FieldState<TValue>>): void;
     handleReset(): void;
-    validate(opts?: Partial<ValidationOptions$1>): Promise<ValidationResult>;
+    validate: FieldValidator;
     handleChange(e: Event | unknown, shouldValidate?: boolean): void;
     handleBlur(e?: Event): void;
     setState(state: Partial<FieldState<TValue>>): void;
@@ -117,55 +276,51 @@ interface PrivateFieldContext<TValue = unknown> {
 type FieldContext<TValue = unknown> = Omit<PrivateFieldContext<TValue>, 'id' | 'instances'>;
 type GenericValidateFunction<TValue = unknown> = (value: TValue, ctx: FieldValidationMetaInfo) => boolean | string | Promise<boolean | string>;
 interface FormState<TValues> {
-    values: TValues;
-    errors: Partial<Record<keyof TValues, string | undefined>>;
-    touched: Partial<Record<keyof TValues, boolean>>;
+    values: PartialDeep<TValues>;
+    errors: Partial<Record<Path<TValues>, string | undefined>>;
+    touched: Partial<Record<Path<TValues>, boolean>>;
     submitCount: number;
 }
-type FormErrors<TValues extends GenericFormValues> = Partial<Record<keyof TValues, string | undefined>>;
-type FormErrorBag<TValues extends GenericFormValues> = Partial<Record<keyof TValues, string[]>>;
+type FormErrors<TValues extends GenericObject> = Partial<Record<Path<TValues>, string | undefined>>;
+type FormErrorBag<TValues extends GenericObject> = Partial<Record<Path<TValues>, string[]>>;
 interface SetFieldValueOptions {
     force: boolean;
 }
-interface FormActions<TValues extends GenericFormValues, TOutput extends TValues = TValues> {
-    setFieldValue<T extends keyof TValues>(field: T, value: TValues[T], opts?: Partial<SetFieldValueOptions>): void;
-    setFieldError(field: keyof TValues, message: string | string[] | undefined): void;
+interface FormActions<TValues extends GenericObject, TOutput = TValues> {
+    setFieldValue<T extends Path<TValues>>(field: T, value: PathValue<TValues, T>, opts?: Partial<SetFieldValueOptions>): void;
+    setFieldError(field: Path<TValues>, message: string | string[] | undefined): void;
     setErrors(fields: FormErrors<TValues>): void;
-    setValues<T extends keyof TValues>(fields: Partial<Record<T, TValues[T]>>): void;
-    setFieldTouched(field: keyof TValues, isTouched: boolean): void;
-    setTouched(fields: Partial<Record<keyof TValues, boolean>>): void;
+    setValues(fields: PartialDeep<TValues>): void;
+    setFieldTouched(field: Path<TValues>, isTouched: boolean): void;
+    setTouched(fields: Partial<Record<Path<TValues>, boolean>>): void;
     resetForm(state?: Partial<FormState<TValues>>): void;
-    resetField(field: keyof TValues, state?: Partial<FieldState>): void;
+    resetField(field: Path<TValues>, state?: Partial<FieldState>): void;
 }
 interface FormValidationResult<TValues, TOutput = TValues> {
     valid: boolean;
-    results: Partial<Record<keyof TValues, ValidationResult>>;
-    errors: Partial<Record<keyof TValues, string>>;
+    results: Partial<Record<Path<TValues>, ValidationResult>>;
+    errors: Partial<Record<Path<TValues>, string>>;
     values?: TOutput;
 }
-interface SubmissionContext<TValues extends GenericFormValues = GenericFormValues> extends FormActions<TValues> {
+interface SubmissionContext<TValues extends GenericObject = GenericObject> extends FormActions<TValues> {
     evt?: Event;
     controlledValues: Partial<TValues>;
 }
-type SubmissionHandler<TValues extends GenericFormValues = GenericFormValues, TOutput extends TValues = TValues, TReturn = unknown> = (values: TOutput, ctx: SubmissionContext<TValues>) => TReturn;
-interface InvalidSubmissionContext<TValues extends GenericFormValues = GenericFormValues> {
+type SubmissionHandler<TValues extends GenericObject = GenericObject, TOutput = TValues, TReturn = unknown> = (values: TOutput, ctx: SubmissionContext<TValues>) => TReturn;
+interface InvalidSubmissionContext<TValues extends GenericObject = GenericObject> {
     values: TValues;
     evt?: Event;
-    errors: Partial<Record<keyof TValues, string>>;
-    results: Partial<Record<keyof TValues, ValidationResult>>;
+    errors: Partial<Record<Path<TValues>, string>>;
+    results: Partial<Record<Path<TValues>, ValidationResult>>;
 }
-type InvalidSubmissionHandler<TValues extends GenericFormValues = GenericFormValues> = (ctx: InvalidSubmissionContext<TValues>) => void;
-type RawFormSchema<TValues> = Record<keyof TValues, string | GenericValidateFunction | Record<string, any>>;
-type FieldPathLookup<TValues extends Record<string, any> = Record<string, any>> = Partial<Record<keyof TValues, PrivateFieldContext | PrivateFieldContext[]>>;
-type MapValues<T, TValues extends Record<string, any>> = {
-    [K in keyof T]: T[K] extends MaybeRef<infer TKey> ? TKey extends keyof TValues ? Ref<TValues[TKey]> : Ref<unknown> : Ref<unknown>;
-};
-type HandleSubmitFactory<TValues extends GenericFormValues, TOutput extends TValues = TValues> = <TReturn = unknown>(cb: SubmissionHandler<TValues, TOutput, TReturn>, onSubmitValidationErrorCb?: InvalidSubmissionHandler<TValues>) => (e?: Event) => Promise<TReturn | undefined>;
-interface PrivateFormContext<TValues extends GenericFormValues = GenericFormValues, TOutput extends TValues = TValues> extends FormActions<TValues> {
+type InvalidSubmissionHandler<TValues extends GenericObject = GenericObject> = (ctx: InvalidSubmissionContext<TValues>) => void;
+type RawFormSchema<TValues> = Record<Path<TValues>, string | GenericValidateFunction | GenericObject>;
+type HandleSubmitFactory<TValues extends GenericObject, TOutput = TValues> = <TReturn = unknown>(cb: SubmissionHandler<TValues, TOutput, TReturn>, onSubmitValidationErrorCb?: InvalidSubmissionHandler<TValues>) => (e?: Event) => Promise<TReturn | undefined>;
+interface PrivateFormContext<TValues extends GenericObject = GenericObject, TOutput = TValues> extends FormActions<TValues> {
     formId: number;
     values: TValues;
+    initialValues: Ref<Partial<TValues>>;
     controlledValues: Ref<TValues>;
-    fieldsByPath: Ref<FieldPathLookup>;
     fieldArrays: PrivateFieldArrayContext[];
     submitCount: Ref<number>;
     schema?: MaybeRef<RawFormSchema<TValues> | TypedSchema<TValues, TOutput> | YupSchema<TValues> | undefined>;
@@ -175,23 +330,61 @@ interface PrivateFormContext<TValues extends GenericFormValues = GenericFormValu
     isSubmitting: Ref<boolean>;
     keepValuesOnUnmount: MaybeRef<boolean>;
     validateSchema?: (mode: SchemaValidationMode) => Promise<FormValidationResult<TValues, TOutput>>;
-    validate(opts?: Partial<ValidationOptions$1>): Promise<FormValidationResult<TValues>>;
-    validateField(field: keyof TValues): Promise<ValidationResult>;
-    setFieldErrorBag(field: string, messages: string | string[]): void;
+    validate(opts?: Partial<ValidationOptions$1>): Promise<FormValidationResult<TValues, TOutput>>;
+    validateField(field: Path<TValues>): Promise<ValidationResult>;
     stageInitialValue(path: string, value: unknown, updateOriginal?: boolean): void;
     unsetInitialValue(path: string): void;
-    register(field: PrivateFieldContext): void;
-    unregister(field: PrivateFieldContext): void;
     handleSubmit: HandleSubmitFactory<TValues, TOutput> & {
         withControlled: HandleSubmitFactory<TValues, TOutput>;
     };
     setFieldInitialValue(path: string, value: unknown): void;
-    useFieldModel<TPath extends keyof TValues>(path: MaybeRef<TPath>): Ref<TValues[TPath]>;
-    useFieldModel<TPath extends keyof TValues>(paths: [...MaybeRef<TPath>[]]): MapValues<typeof paths, TValues>;
+    useFieldModel<TPath extends Path<TValues>>(path: TPath): Ref<PathValue<TValues, TPath>>;
+    useFieldModel<TPaths extends readonly [...MaybeRef<Path<TValues>>[]]>(paths: TPaths): MapValuesPathsToRefs<TValues, TPaths>;
+    createPathState<TPath extends Path<TValues>>(path: MaybeRef<TPath>, config?: Partial<PathStateConfig>): PathState<PathValue<TValues, TPath>>;
+    getPathState<TPath extends Path<TValues>>(path: TPath): PathState<PathValue<TValues, TPath>> | undefined;
+    getAllPathStates(): PathState[];
+    removePathState<TPath extends Path<TValues>>(path: TPath): void;
+    unsetPathValue<TPath extends Path<TValues>>(path: TPath): void;
 }
-interface FormContext<TValues extends Record<string, any> = Record<string, any>, TOutput extends TValues = TValues> extends Omit<PrivateFormContext<TValues, TOutput>, 'formId' | 'register' | 'unregister' | 'fieldsByPath' | 'schema' | 'validateSchema' | 'setFieldErrorBag' | 'stageInitialValue' | 'setFieldInitialValue' | 'unsetInitialValue' | 'fieldArrays' | 'keepValuesOnUnmount'> {
+interface BaseComponentBinds<TValue = unknown> {
+    modelValue: TValue | undefined;
+    'onUpdate:modelValue': (value: TValue) => void;
+    onBlur: () => void;
+}
+type PublicPathState<TValue = unknown> = Omit<PathState<TValue>, 'bails' | 'label' | 'multiple' | 'fieldsCount' | 'validate' | 'id' | 'type'>;
+interface ComponentBindsConfig<TValue = unknown, TExtraProps extends GenericObject = GenericObject> {
+    mapProps: (state: PublicPathState<TValue>) => TExtraProps;
+    validateOnBlur: boolean;
+    validateOnModelUpdate: boolean;
+}
+type LazyComponentBindsConfig<TValue = unknown, TExtraProps extends GenericObject = GenericObject> = (state: PublicPathState<TValue>) => Partial<{
+    props: TExtraProps;
+    validateOnBlur: boolean;
+    validateOnModelUpdate: boolean;
+}>;
+interface BaseInputBinds<TValue = unknown> {
+    value: TValue | undefined;
+    onBlur: (e: Event) => void;
+    onChange: (e: Event) => void;
+    onInput: (e: Event) => void;
+}
+interface InputBindsConfig<TValue = unknown, TExtraProps extends GenericObject = GenericObject> {
+    mapAttrs: (state: PublicPathState<TValue>) => TExtraProps;
+    validateOnBlur: boolean;
+    validateOnChange: boolean;
+    validateOnInput: boolean;
+}
+type LazyInputBindsConfig<TValue = unknown, TExtraProps extends GenericObject = GenericObject> = (state: PublicPathState<TValue>) => Partial<{
+    attrs: TExtraProps;
+    validateOnBlur: boolean;
+    validateOnChange: boolean;
+    validateOnInput: boolean;
+}>;
+interface FormContext<TValues extends GenericObject = GenericObject, TOutput = TValues> extends Omit<PrivateFormContext<TValues, TOutput>, 'formId' | 'schema' | 'initialValues' | 'getPathState' | 'getAllPathStates' | 'removePathState' | 'unsetPathValue' | 'validateSchema' | 'stageInitialValue' | 'setFieldInitialValue' | 'unsetInitialValue' | 'fieldArrays' | 'keepValuesOnUnmount'> {
     handleReset: () => void;
     submitForm: (e?: unknown) => Promise<void>;
+    defineComponentBinds<TPath extends Path<TValues>, TValue = PathValue<TValues, TPath>, TExtras extends GenericObject = GenericObject>(path: MaybeRefOrLazy<TPath>, config?: Partial<ComponentBindsConfig<TValue, TExtras>> | LazyComponentBindsConfig<TValue, TExtras>): Ref<BaseComponentBinds<TValue> & TExtras>;
+    defineInputBinds<TPath extends Path<TValues>, TValue = PathValue<TValues, TPath>, TExtras extends GenericObject = GenericObject>(path: MaybeRefOrLazy<TPath>, config?: Partial<InputBindsConfig<TValue, TExtras>> | LazyInputBindsConfig<TValue, TExtras>): Ref<BaseInputBinds<TValue> & TExtras>;
 }
 
 interface ValidationOptions {
@@ -232,7 +425,7 @@ interface FieldOptions<TValue = unknown> {
     validateOnValueUpdate: boolean;
     validateOnMount?: boolean;
     bails?: boolean;
-    type?: string;
+    type?: InputType;
     valueProp?: MaybeRef<TValue>;
     checkedValue?: MaybeRef<TValue>;
     uncheckedValue?: MaybeRef<TValue>;
@@ -250,11 +443,12 @@ type RuleExpression<TValue> = string | Record<string, unknown> | GenericValidate
  */
 declare function useField<TValue = unknown>(path: MaybeRefOrLazy<string>, rules?: MaybeRef<RuleExpression<TValue>>, opts?: Partial<FieldOptions<TValue>>): FieldContext<TValue>;
 
+type EventHandlerBinding<T> = T | T[];
 interface FieldBindingObject<TValue = unknown> {
     name: string;
-    onBlur: (e: Event) => unknown;
-    onInput: (e: Event) => unknown;
-    onChange: (e: Event) => unknown;
+    onBlur: EventHandlerBinding<(e: Event) => unknown>;
+    onInput: EventHandlerBinding<(e: Event) => unknown>;
+    onChange: EventHandlerBinding<(e: Event) => unknown>;
     'onUpdate:modelValue'?: ((e: TValue) => unknown) | undefined;
     value?: unknown;
     checked?: boolean;
@@ -655,23 +849,23 @@ declare const Field: {
 type FormSlotProps = UnwrapRef<Pick<FormContext, 'meta' | 'errors' | 'errorBag' | 'values' | 'isSubmitting' | 'submitCount' | 'validate' | 'validateField' | 'handleReset' | 'setErrors' | 'setFieldError' | 'setFieldValue' | 'setValues' | 'setFieldTouched' | 'setTouched' | 'resetForm' | 'resetField' | 'controlledValues'>> & {
     handleSubmit: (evt: Event | SubmissionHandler, onSubmit?: SubmissionHandler) => Promise<unknown>;
     submitForm(evt?: Event): void;
-    getValues<TValues extends GenericFormValues = GenericFormValues>(): TValues;
-    getMeta<TValues extends GenericFormValues = GenericFormValues>(): FormMeta<TValues>;
-    getErrors<TValues extends GenericFormValues = GenericFormValues>(): FormErrors<TValues>;
+    getValues<TValues extends GenericObject = GenericObject>(): TValues;
+    getMeta<TValues extends GenericObject = GenericObject>(): FormMeta<TValues>;
+    getErrors<TValues extends GenericObject = GenericObject>(): FormErrors<TValues>;
 };
 declare const Form: {
     new (...args: any[]): {
         $: vue.ComponentInternalInstance;
         $data: {};
         $props: Partial<{
-            onSubmit: SubmissionHandler<GenericFormValues, GenericFormValues, unknown>;
+            onSubmit: SubmissionHandler;
             as: string;
             initialValues: Record<string, any>;
             validateOnMount: boolean;
             validationSchema: Record<string, any>;
             initialErrors: Record<string, any>;
             initialTouched: Record<string, any>;
-            onInvalidSubmit: InvalidSubmissionHandler<GenericFormValues>;
+            onInvalidSubmit: InvalidSubmissionHandler;
             keepValues: boolean;
         }> & Omit<Readonly<vue.ExtractPropTypes<{
             as: {
@@ -699,11 +893,11 @@ declare const Form: {
                 default: boolean;
             };
             onSubmit: {
-                type: PropType<SubmissionHandler<GenericFormValues, GenericFormValues, unknown>>;
+                type: PropType<SubmissionHandler>;
                 default: any;
             };
             onInvalidSubmit: {
-                type: PropType<InvalidSubmissionHandler<GenericFormValues>>;
+                type: PropType<InvalidSubmissionHandler>;
                 default: any;
             };
             keepValues: {
@@ -750,11 +944,11 @@ declare const Form: {
                 default: boolean;
             };
             onSubmit: {
-                type: PropType<SubmissionHandler<GenericFormValues, GenericFormValues, unknown>>;
+                type: PropType<SubmissionHandler>;
                 default: any;
             };
             onInvalidSubmit: {
-                type: PropType<InvalidSubmissionHandler<GenericFormValues>>;
+                type: PropType<InvalidSubmissionHandler>;
                 default: any;
             };
             keepValues: {
@@ -770,14 +964,14 @@ declare const Form: {
                 [key: string]: any;
             }>[];
         }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
-            onSubmit: SubmissionHandler<GenericFormValues, GenericFormValues, unknown>;
+            onSubmit: SubmissionHandler;
             as: string;
             initialValues: Record<string, any>;
             validateOnMount: boolean;
             validationSchema: Record<string, any>;
             initialErrors: Record<string, any>;
             initialTouched: Record<string, any>;
-            onInvalidSubmit: InvalidSubmissionHandler<GenericFormValues>;
+            onInvalidSubmit: InvalidSubmissionHandler;
             keepValues: boolean;
         }, {}, string> & {
             beforeCreate?: (() => void) | (() => void)[];
@@ -825,11 +1019,11 @@ declare const Form: {
             default: boolean;
         };
         onSubmit: {
-            type: PropType<SubmissionHandler<GenericFormValues, GenericFormValues, unknown>>;
+            type: PropType<SubmissionHandler>;
             default: any;
         };
         onInvalidSubmit: {
-            type: PropType<InvalidSubmissionHandler<GenericFormValues>>;
+            type: PropType<InvalidSubmissionHandler>;
             default: any;
         };
         keepValues: {
@@ -874,11 +1068,11 @@ declare const Form: {
         default: boolean;
     };
     onSubmit: {
-        type: PropType<SubmissionHandler<GenericFormValues, GenericFormValues, unknown>>;
+        type: PropType<SubmissionHandler>;
         default: any;
     };
     onInvalidSubmit: {
-        type: PropType<InvalidSubmissionHandler<GenericFormValues>>;
+        type: PropType<InvalidSubmissionHandler>;
         default: any;
     };
     keepValues: {
@@ -894,14 +1088,14 @@ declare const Form: {
         [key: string]: any;
     }>[];
 }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
-    onSubmit: SubmissionHandler<GenericFormValues, GenericFormValues, unknown>;
+    onSubmit: SubmissionHandler;
     as: string;
     initialValues: Record<string, any>;
     validateOnMount: boolean;
     validationSchema: Record<string, any>;
     initialErrors: Record<string, any>;
     initialTouched: Record<string, any>;
-    onInvalidSubmit: InvalidSubmissionHandler<GenericFormValues>;
+    onInvalidSubmit: InvalidSubmissionHandler;
     keepValues: boolean;
 }, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new () => {
     setFieldError: FormContext['setFieldError'];
@@ -1133,16 +1327,16 @@ declare const ErrorMessage: {
     };
 });
 
-type FormSchema<TValues> = Record<keyof TValues, GenericValidateFunction | string | GenericFormValues> | undefined;
-interface FormOptions<TValues extends GenericFormValues, TOutput extends TValues = TValues, TSchema extends TypedSchema<TValues, TOutput> | FormSchema<TValues> = FormSchema<TValues> | TypedSchema<TValues, TOutput>> {
+type FormSchema<TValues extends Record<string, unknown>> = FlattenAndSetPathsType<TValues, GenericValidateFunction | string | GenericObject> | undefined;
+interface FormOptions<TValues extends GenericObject, TOutput = TValues, TSchema extends TypedSchema<TValues, TOutput> | FormSchema<TValues> = FormSchema<TValues> | TypedSchema<TValues, TOutput>> {
     validationSchema?: MaybeRef<TSchema extends TypedSchema ? TypedSchema<TValues, TOutput> : any>;
-    initialValues?: MaybeRef<Partial<TValues>>;
-    initialErrors?: Record<keyof TValues, string | undefined>;
-    initialTouched?: Record<keyof TValues, boolean>;
+    initialValues?: MaybeRef<PartialDeep<TValues>>;
+    initialErrors?: FlattenAndSetPathsType<TValues, string | undefined>;
+    initialTouched?: FlattenAndSetPathsType<TValues, boolean>;
     validateOnMount?: boolean;
     keepValuesOnUnmount?: MaybeRef<boolean>;
 }
-declare function useForm<TValues extends GenericFormValues = GenericFormValues, TOutput extends TValues = TValues, TSchema extends FormSchema<TValues> | TypedSchema<TValues, TOutput> = FormSchema<TValues> | TypedSchema<TValues, TOutput>>(opts?: FormOptions<TValues, TOutput, TSchema>): FormContext<TValues, TOutput>;
+declare function useForm<TValues extends GenericObject = GenericObject, TOutput = TValues, TSchema extends FormSchema<TValues> | TypedSchema<TValues, TOutput> = FormSchema<TValues> | TypedSchema<TValues, TOutput>>(opts?: FormOptions<TValues, TOutput, TSchema>): FormContext<TValues, TOutput>;
 
 declare function useFieldArray<TValue = unknown>(arrayPath: MaybeRef<string>): FieldArrayContext<TValue>;
 
@@ -1211,7 +1405,7 @@ declare function useFormValues<TValues extends Record<string, any> = Record<stri
 /**
  * Gives access to all form errors
  */
-declare function useFormErrors<TValues extends Record<string, unknown> = Record<string, unknown>>(): vue.ComputedRef<Partial<Record<keyof TValues, string>>>;
+declare function useFormErrors<TValues extends Record<string, unknown> = Record<string, unknown>>(): vue.ComputedRef<Partial<Record<Path<TValues>, string>>>;
 
 /**
  * Gives access to a single field error
@@ -1224,4 +1418,4 @@ declare const FormContextKey: InjectionKey<PrivateFormContext>;
 declare const FieldContextKey: InjectionKey<PrivateFieldContext<unknown>>;
 declare const IS_ABSENT: any;
 
-export { ErrorMessage, Field, FieldArray, FieldArrayContext, FieldContext, FieldContextKey, FieldEntry, FieldMeta, FieldOptions, FieldState, Form, FormActions, FormContext, FormContextKey, FormMeta, FormOptions, FormState, FormValidationResult, GenericValidateFunction, IS_ABSENT, InvalidSubmissionContext, InvalidSubmissionHandler, RawFormSchema, RuleExpression, SubmissionContext, SubmissionHandler, TypedSchema, TypedSchemaError, ValidationOptions$1 as ValidationOptions, ValidationResult, configure, defineRule, useField, useFieldArray, useFieldError, useFieldValue, useForm, useFormErrors, useFormValues, useIsFieldDirty, useIsFieldTouched, useIsFieldValid, useIsFormDirty, useIsFormTouched, useIsFormValid, useIsSubmitting, useResetForm, useSubmitCount, useSubmitForm, useValidateField, useValidateForm, validate, validateObjectSchema as validateObject };
+export { ComponentBindsConfig, ErrorMessage, Field, FieldArray, FieldArrayContext, FieldContext, FieldContextKey, FieldEntry, FieldMeta, FieldOptions, FieldState, Form, FormActions, FormContext, FormContextKey, FormMeta, FormOptions, FormState, FormValidationResult, GenericValidateFunction, IS_ABSENT, InputBindsConfig, InvalidSubmissionContext, InvalidSubmissionHandler, LazyComponentBindsConfig, LazyInputBindsConfig, Path, PublicPathState as PathState, RawFormSchema, RuleExpression, SubmissionContext, SubmissionHandler, TypedSchema, TypedSchemaError, ValidationOptions$1 as ValidationOptions, ValidationResult, configure, defineRule, useField, useFieldArray, useFieldError, useFieldValue, useForm, useFormErrors, useFormValues, useIsFieldDirty, useIsFieldTouched, useIsFieldValid, useIsFormDirty, useIsFormTouched, useIsFormValid, useIsSubmitting, useResetForm, useSubmitCount, useSubmitForm, useValidateField, useValidateForm, validate, validateObjectSchema as validateObject };