vee-validate 4.5.1 → 4.5.5

package/dist/vee-validate.d.ts

@@ -1,5 +1,5 @@
 import * as vue from 'vue';
-import { Ref, DeepReadonly, ComputedRef, PropType, InjectionKey } from 'vue';
+import { DeepReadonly, Ref, ComputedRef, VNode, UnwrapRef, InjectionKey } from 'vue';
 import { AnySchema, AnyObjectSchema, SchemaOf, BaseSchema } from 'yup';
 
 interface FieldValidationMetaInfo {
@@ -204,76 +204,211 @@ declare type RuleExpression<TValue> = string | Record<string, unknown> | Generic
  */
 declare function useField<TValue = unknown>(name: MaybeRef<string>, rules?: MaybeRef<RuleExpression<TValue>>, opts?: Partial<FieldOptions<TValue>>): FieldContext<TValue>;
 
-declare const Field: vue.DefineComponent<{
-    as: {
-        type: (ObjectConstructor | StringConstructor)[];
-        default: any;
-    };
-    name: {
-        type: StringConstructor;
-        required: true;
-    };
-    rules: {
-        type: PropType<RuleExpression<unknown>>;
-        default: any;
-    };
-    validateOnMount: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    validateOnBlur: {
-        type: BooleanConstructor;
-        default: any;
-    };
-    validateOnChange: {
-        type: BooleanConstructor;
-        default: any;
-    };
-    validateOnInput: {
-        type: BooleanConstructor;
-        default: any;
-    };
-    validateOnModelUpdate: {
-        type: BooleanConstructor;
-        default: any;
-    };
-    bails: {
-        type: BooleanConstructor;
-        default: () => boolean;
-    };
-    label: {
-        type: StringConstructor;
-        default: any;
-    };
-    uncheckedValue: {
-        type: any;
-        default: any;
-    };
-    modelValue: {
-        type: any;
-        default: symbol;
-    };
-    modelModifiers: {
-        type: any;
-        default: () => {};
-    };
-    'onUpdate:modelValue': {
-        type: PropType<(e: any) => unknown>;
-        default: any;
-    };
-    standalone: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-    [key: string]: any;
-}> | vue.Slot | vue.VNode<vue.RendererNode, vue.RendererElement, {
-    [key: string]: any;
-}>[] | {
-    default: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+interface FieldBindingObject<TValue = unknown> {
+    name: string;
+    onBlur: (e: Event) => unknown;
+    onInput: (e: Event) => unknown;
+    onChange: (e: Event) => unknown;
+    'onUpdate:modelValue'?: ((e: TValue) => unknown) | undefined;
+    value?: unknown;
+    checked?: boolean;
+}
+interface FieldSlotProps<TValue = unknown> extends Pick<FieldContext, 'validate' | 'resetField' | 'handleChange' | 'handleReset' | 'handleBlur' | 'setTouched' | 'setErrors'> {
+    field: FieldBindingObject<TValue>;
+    value: TValue;
+    meta: FieldMeta<TValue>;
+    errors: string[];
+    errorMessage: string | undefined;
+    handleInput: FieldContext['handleChange'];
+}
+declare const Field: {
+    new (...args: any[]): {
+        $: vue.ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            label: string;
+            as: string | Record<string, any>;
+            bails: boolean;
+            uncheckedValue: any;
+            validateOnInput: boolean;
+            validateOnChange: boolean;
+            validateOnBlur: boolean;
+            validateOnModelUpdate: boolean;
+            modelValue: any;
+            standalone: boolean;
+            validateOnMount: boolean;
+            rules: RuleExpression<unknown>;
+            modelModifiers: any;
+            "onUpdate:modelValue": (e: any) => unknown;
+        }> & Omit<Readonly<{
+            as?: unknown;
+            name?: unknown;
+            rules?: unknown;
+            validateOnMount?: unknown;
+            validateOnBlur?: unknown;
+            validateOnChange?: unknown;
+            validateOnInput?: unknown;
+            validateOnModelUpdate?: unknown;
+            bails?: unknown;
+            label?: unknown;
+            uncheckedValue?: unknown;
+            modelValue?: unknown;
+            modelModifiers?: unknown;
+            'onUpdate:modelValue'?: unknown;
+            standalone?: unknown;
+        } & {
+            name: string;
+            bails: boolean;
+            modelValue: any;
+            standalone: boolean;
+            validateOnMount: boolean;
+            modelModifiers: any;
+        } & {
+            label?: string;
+            as?: string | Record<string, any>;
+            uncheckedValue?: any;
+            validateOnInput?: boolean;
+            validateOnChange?: boolean;
+            validateOnBlur?: boolean;
+            validateOnModelUpdate?: boolean;
+            rules?: RuleExpression<unknown>;
+            "onUpdate:modelValue"?: (e: any) => unknown;
+        }> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "label" | "as" | "bails" | "uncheckedValue" | "validateOnInput" | "validateOnChange" | "validateOnBlur" | "validateOnModelUpdate" | "modelValue" | "standalone" | "validateOnMount" | "rules" | "modelModifiers" | "onUpdate:modelValue">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: vue.Slot;
+        }>;
+        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
+        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: vue.ComponentOptionsBase<Readonly<{
+            as?: unknown;
+            name?: unknown;
+            rules?: unknown;
+            validateOnMount?: unknown;
+            validateOnBlur?: unknown;
+            validateOnChange?: unknown;
+            validateOnInput?: unknown;
+            validateOnModelUpdate?: unknown;
+            bails?: unknown;
+            label?: unknown;
+            uncheckedValue?: unknown;
+            modelValue?: unknown;
+            modelModifiers?: unknown;
+            'onUpdate:modelValue'?: unknown;
+            standalone?: unknown;
+        } & {
+            name: string;
+            bails: boolean;
+            modelValue: any;
+            standalone: boolean;
+            validateOnMount: boolean;
+            modelModifiers: any;
+        } & {
+            label?: string;
+            as?: string | Record<string, any>;
+            uncheckedValue?: any;
+            validateOnInput?: boolean;
+            validateOnChange?: boolean;
+            validateOnBlur?: boolean;
+            validateOnModelUpdate?: boolean;
+            rules?: RuleExpression<unknown>;
+            "onUpdate:modelValue"?: (e: any) => unknown;
+        }>, () => VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }> | vue.Slot | VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[] | {
+            default: () => VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[];
+        }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
+            label: string;
+            as: string | Record<string, any>;
+            bails: boolean;
+            uncheckedValue: any;
+            validateOnInput: boolean;
+            validateOnChange: boolean;
+            validateOnBlur: boolean;
+            validateOnModelUpdate: boolean;
+            modelValue: any;
+            standalone: boolean;
+            validateOnMount: boolean;
+            rules: RuleExpression<unknown>;
+            modelModifiers: any;
+            "onUpdate:modelValue": (e: any) => unknown;
+        }> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
+            renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof vue.nextTick;
+        $watch(source: string | Function, cb: Function, options?: vue.WatchOptions<boolean>): vue.WatchStopHandle;
+    } & Readonly<{
+        as?: unknown;
+        name?: unknown;
+        rules?: unknown;
+        validateOnMount?: unknown;
+        validateOnBlur?: unknown;
+        validateOnChange?: unknown;
+        validateOnInput?: unknown;
+        validateOnModelUpdate?: unknown;
+        bails?: unknown;
+        label?: unknown;
+        uncheckedValue?: unknown;
+        modelValue?: unknown;
+        modelModifiers?: unknown;
+        'onUpdate:modelValue'?: unknown;
+        standalone?: unknown;
+    } & {
+        name: string;
+        bails: boolean;
+        modelValue: any;
+        standalone: boolean;
+        validateOnMount: boolean;
+        modelModifiers: any;
+    } & {
+        label?: string;
+        as?: string | Record<string, any>;
+        uncheckedValue?: any;
+        validateOnInput?: boolean;
+        validateOnChange?: boolean;
+        validateOnBlur?: boolean;
+        validateOnModelUpdate?: boolean;
+        rules?: RuleExpression<unknown>;
+        "onUpdate:modelValue"?: (e: any) => unknown;
+    }> & vue.ShallowUnwrapRef<() => VNode<vue.RendererNode, vue.RendererElement, {
         [key: string]: any;
-    }>[];
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<{
+    }> | vue.Slot | VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[] | {
+        default: () => VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+    }> & {} & {} & vue.ComponentCustomProperties;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & vue.ComponentOptionsBase<Readonly<{
     as?: unknown;
     name?: unknown;
     rules?: unknown;
@@ -306,7 +441,15 @@ declare const Field: vue.DefineComponent<{
     validateOnModelUpdate?: boolean;
     rules?: RuleExpression<unknown>;
     "onUpdate:modelValue"?: (e: any) => unknown;
-}>, {
+}>, () => VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | vue.Slot | VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>[] | {
+    default: () => VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
     label: string;
     as: string | Record<string, any>;
     bails: boolean;
@@ -321,50 +464,149 @@ declare const Field: vue.DefineComponent<{
     rules: RuleExpression<unknown>;
     modelModifiers: any;
     "onUpdate:modelValue": (e: any) => unknown;
-}>;
-
-declare const Form: vue.DefineComponent<{
-    as: {
-        type: StringConstructor;
-        default: string;
-    };
-    validationSchema: {
-        type: ObjectConstructor;
-        default: any;
-    };
-    initialValues: {
-        type: ObjectConstructor;
-        default: any;
-    };
-    initialErrors: {
-        type: ObjectConstructor;
-        default: any;
-    };
-    initialTouched: {
-        type: ObjectConstructor;
-        default: any;
+}> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new () => {
+    $slots: {
+        default: (arg: FieldSlotProps<unknown>) => VNode[];
     };
-    validateOnMount: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    onSubmit: {
-        type: PropType<SubmissionHandler<GenericFormValues, unknown>>;
-        default: any;
-    };
-    onInvalidSubmit: {
-        type: PropType<InvalidSubmissionHandler<GenericFormValues>>;
-        default: any;
-    };
-}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-    [key: string]: any;
-}> | vue.Slot | vue.VNode<vue.RendererNode, vue.RendererElement, {
-    [key: string]: any;
-}>[] | {
-    default: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+});
+
+declare type FormSlotProps = UnwrapRef<Pick<FormContext, 'meta' | 'errors' | 'values' | 'isSubmitting' | 'submitCount' | 'validate' | 'validateField' | 'handleReset' | 'submitForm' | 'setErrors' | 'setFieldError' | 'setFieldValue' | 'setValues' | 'setFieldTouched' | 'setTouched' | 'resetForm'>> & {
+    handleSubmit: (evt: Event | SubmissionHandler, onSubmit?: SubmissionHandler) => Promise<unknown>;
+};
+declare const Form: {
+    new (...args: any[]): {
+        $: vue.ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            onSubmit: SubmissionHandler<GenericFormValues, unknown>;
+            as: string;
+            initialValues: Record<string, any>;
+            validateOnMount: boolean;
+            validationSchema: Record<string, any>;
+            initialErrors: Record<string, any>;
+            initialTouched: Record<string, any>;
+            onInvalidSubmit: InvalidSubmissionHandler<GenericFormValues>;
+        }> & Omit<Readonly<{
+            as?: unknown;
+            validationSchema?: unknown;
+            initialValues?: unknown;
+            initialErrors?: unknown;
+            initialTouched?: unknown;
+            validateOnMount?: unknown;
+            onSubmit?: unknown;
+            onInvalidSubmit?: unknown;
+        } & {
+            as: string;
+            validateOnMount: boolean;
+        } & {
+            onSubmit?: SubmissionHandler<GenericFormValues, unknown>;
+            initialValues?: Record<string, any>;
+            validationSchema?: Record<string, any>;
+            initialErrors?: Record<string, any>;
+            initialTouched?: Record<string, any>;
+            onInvalidSubmit?: InvalidSubmissionHandler<GenericFormValues>;
+        }> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "onSubmit" | "as" | "initialValues" | "validateOnMount" | "validationSchema" | "initialErrors" | "initialTouched" | "onInvalidSubmit">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: vue.Slot;
+        }>;
+        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
+        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: vue.ComponentOptionsBase<Readonly<{
+            as?: unknown;
+            validationSchema?: unknown;
+            initialValues?: unknown;
+            initialErrors?: unknown;
+            initialTouched?: unknown;
+            validateOnMount?: unknown;
+            onSubmit?: unknown;
+            onInvalidSubmit?: unknown;
+        } & {
+            as: string;
+            validateOnMount: boolean;
+        } & {
+            onSubmit?: SubmissionHandler<GenericFormValues, unknown>;
+            initialValues?: Record<string, any>;
+            validationSchema?: Record<string, any>;
+            initialErrors?: Record<string, any>;
+            initialTouched?: Record<string, any>;
+            onInvalidSubmit?: InvalidSubmissionHandler<GenericFormValues>;
+        }>, () => VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }> | vue.Slot | VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[] | {
+            default: () => VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[];
+        }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
+            onSubmit: SubmissionHandler<GenericFormValues, unknown>;
+            as: string;
+            initialValues: Record<string, any>;
+            validateOnMount: boolean;
+            validationSchema: Record<string, any>;
+            initialErrors: Record<string, any>;
+            initialTouched: Record<string, any>;
+            onInvalidSubmit: InvalidSubmissionHandler<GenericFormValues>;
+        }> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
+            renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof vue.nextTick;
+        $watch(source: string | Function, cb: Function, options?: vue.WatchOptions<boolean>): vue.WatchStopHandle;
+    } & Readonly<{
+        as?: unknown;
+        validationSchema?: unknown;
+        initialValues?: unknown;
+        initialErrors?: unknown;
+        initialTouched?: unknown;
+        validateOnMount?: unknown;
+        onSubmit?: unknown;
+        onInvalidSubmit?: unknown;
+    } & {
+        as: string;
+        validateOnMount: boolean;
+    } & {
+        onSubmit?: SubmissionHandler<GenericFormValues, unknown>;
+        initialValues?: Record<string, any>;
+        validationSchema?: Record<string, any>;
+        initialErrors?: Record<string, any>;
+        initialTouched?: Record<string, any>;
+        onInvalidSubmit?: InvalidSubmissionHandler<GenericFormValues>;
+    }> & vue.ShallowUnwrapRef<() => VNode<vue.RendererNode, vue.RendererElement, {
         [key: string]: any;
-    }>[];
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<{
+    }> | vue.Slot | VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[] | {
+        default: () => VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+    }> & {} & {} & vue.ComponentCustomProperties;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & vue.ComponentOptionsBase<Readonly<{
     as?: unknown;
     validationSchema?: unknown;
     initialValues?: unknown;
@@ -383,7 +625,15 @@ declare const Form: vue.DefineComponent<{
     initialErrors?: Record<string, any>;
     initialTouched?: Record<string, any>;
     onInvalidSubmit?: InvalidSubmissionHandler<GenericFormValues>;
-}>, {
+}>, () => VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | vue.Slot | VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>[] | {
+    default: () => VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
     onSubmit: SubmissionHandler<GenericFormValues, unknown>;
     as: string;
     initialValues: Record<string, any>;
@@ -392,52 +642,202 @@ declare const Form: vue.DefineComponent<{
     initialErrors: Record<string, any>;
     initialTouched: Record<string, any>;
     onInvalidSubmit: InvalidSubmissionHandler<GenericFormValues>;
-}>;
-
-declare const FieldArray: vue.DefineComponent<{
-    name: {
-        type: StringConstructor;
-        required: true;
+}> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new () => {
+    $slots: {
+        default: (arg: FormSlotProps) => VNode[];
     };
-}, () => vue.Slot | vue.VNode<vue.RendererNode, vue.RendererElement, {
-    [key: string]: any;
-}>[] | {
-    default: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+});
+
+declare const FieldArray: {
+    new (...args: any[]): {
+        $: vue.ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<Readonly<{
+            name?: unknown;
+        } & {
+            name: string;
+        } & {}> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, never>;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: vue.Slot;
+        }>;
+        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
+        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: vue.ComponentOptionsBase<Readonly<{
+            name?: unknown;
+        } & {
+            name: string;
+        } & {}>, () => vue.Slot | VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[] | {
+            default: () => VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[];
+        }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {}> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
+            renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof vue.nextTick;
+        $watch(source: string | Function, cb: Function, options?: vue.WatchOptions<boolean>): vue.WatchStopHandle;
+    } & Readonly<{
+        name?: unknown;
+    } & {
+        name: string;
+    } & {}> & vue.ShallowUnwrapRef<() => vue.Slot | VNode<vue.RendererNode, vue.RendererElement, {
         [key: string]: any;
-    }>[];
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<{
+    }>[] | {
+        default: () => VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+    }> & {} & {} & vue.ComponentCustomProperties;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & vue.ComponentOptionsBase<Readonly<{
     name?: unknown;
 } & {
     name: string;
-} & {}>, {}>;
-
-declare const ErrorMessage: vue.DefineComponent<{
-    as: {
-        type: StringConstructor;
-        default: any;
-    };
-    name: {
-        type: StringConstructor;
-        required: true;
-    };
-}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-    [key: string]: any;
-}> | vue.Slot | vue.VNode<vue.RendererNode, vue.RendererElement, {
+} & {}>, () => vue.Slot | VNode<vue.RendererNode, vue.RendererElement, {
     [key: string]: any;
 }>[] | {
-    default: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    default: () => VNode<vue.RendererNode, vue.RendererElement, {
         [key: string]: any;
     }>[];
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<{
+}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {}> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new () => {
+    $slots: {
+        default: (arg: UnwrapRef<FieldArrayContext>) => VNode[];
+    };
+});
+
+interface ErrorMessageSlotProps {
+    message: string | undefined;
+}
+declare const ErrorMessage: {
+    new (...args: any[]): {
+        $: vue.ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            as: string;
+        }> & Omit<Readonly<{
+            as?: unknown;
+            name?: unknown;
+        } & {
+            name: string;
+        } & {
+            as?: string;
+        }> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "as">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: vue.Slot;
+        }>;
+        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
+        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: vue.ComponentOptionsBase<Readonly<{
+            as?: unknown;
+            name?: unknown;
+        } & {
+            name: string;
+        } & {
+            as?: string;
+        }>, () => VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }> | vue.Slot | VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[] | {
+            default: () => VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[];
+        }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
+            as: string;
+        }> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
+            renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof vue.nextTick;
+        $watch(source: string | Function, cb: Function, options?: vue.WatchOptions<boolean>): vue.WatchStopHandle;
+    } & Readonly<{
+        as?: unknown;
+        name?: unknown;
+    } & {
+        name: string;
+    } & {
+        as?: string;
+    }> & vue.ShallowUnwrapRef<() => VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }> | vue.Slot | VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[] | {
+        default: () => VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+    }> & {} & {} & vue.ComponentCustomProperties;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & vue.ComponentOptionsBase<Readonly<{
     as?: unknown;
     name?: unknown;
 } & {
     name: string;
 } & {
     as?: string;
-}>, {
+}>, () => VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | vue.Slot | VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>[] | {
+    default: () => VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
     as: string;
-}>;
+}> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new () => {
+    $slots: {
+        default: (arg: ErrorMessageSlotProps) => VNode[];
+    };
+});
 
 interface FormOptions<TValues extends Record<string, any>> {
     validationSchema?: MaybeRef<Record<keyof TValues, GenericValidateFunction | string | Record<string, any>> | SchemaOf<TValues> | undefined>;
@@ -527,4 +927,4 @@ declare function useSubmitForm<TValues extends Record<string, unknown> = Record<
 declare const FormContextKey: InjectionKey<PrivateFormContext>;
 declare const FieldContextKey: InjectionKey<PrivateFieldContext<unknown>>;
 
-export { ErrorMessage, Field, FieldArray, FieldContext, FieldContextKey, Form, FormActions, FormContext, FormContextKey, FormState, FormValidationResult, SubmissionContext, SubmissionHandler, ValidationResult, configure, defineRule, useField, useFieldArray, useFieldError, useFieldValue, useForm, useFormErrors, useFormValues, useIsFieldDirty, useIsFieldTouched, useIsFieldValid, useIsFormDirty, useIsFormTouched, useIsFormValid, useIsSubmitting, useResetForm, useSubmitCount, useSubmitForm, useValidateField, useValidateForm, validate };
+export { ErrorMessage, Field, FieldArray, FieldArrayContext, FieldContext, FieldContextKey, FieldEntry, FieldMeta, Form, FormActions, FormContext, FormContextKey, FormMeta, FormState, FormValidationResult, InvalidSubmissionContext, SubmissionContext, SubmissionHandler, ValidationResult, configure, defineRule, useField, useFieldArray, useFieldError, useFieldValue, useForm, useFormErrors, useFormValues, useIsFieldDirty, useIsFieldTouched, useIsFieldValid, useIsFormDirty, useIsFormTouched, useIsFormValid, useIsSubmitting, useResetForm, useSubmitCount, useSubmitForm, useValidateField, useValidateForm, validate };