@volverjs/form-vue/dist/index.d.ts

Vue 3 Forms with @volverjs/ui-vue

import { InjectionKey, Plugin } from 'vue';
import { defineForm } from './VvForm';
import { defineFormField } from './VvFormField';
import { defineFormFieldsGroup } from './VvFormFieldsGroup';
import { defineFormWrapper } from './VvFormWrapper';
import { InjectedFormData, InjectedFormWrapperData, InjectedFormFieldData, FormComposableOptions, FormPluginOptions, FormTemplateItem, Path, PathValue, FormSchema, FormTemplate } from './types';
declare function _formType<Schema extends FormSchema, Type>(schema: Schema, options?: FormComposableOptions<Schema, Type>): {
    clear: () => void;
    errors: import('vue').Ref<import('./types').InferFormattedError<Schema> | undefined, import('./types').InferFormattedError<Schema> | undefined>;
    formData: import('vue').Ref<(undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined>;
    formFieldInjectionKey: InjectionKey<InjectedFormFieldData<Schema>>;
    formInjectionKey: InjectionKey<InjectedFormData<Schema, Type>>;
    formWrapperInjectionKey: InjectionKey<InjectedFormWrapperData<Schema>>;
    ignoreUpdates: import('@vueuse/shared').IgnoredUpdater;
    invalid: import('vue').ComputedRef<boolean>;
    readonly: import('vue').Ref<boolean, boolean>;
    reset: () => void;
    status: import('vue').Ref<import('./enums').FormStatus | undefined, import('./enums').FormStatus | undefined>;
    stopUpdatesWatch: import('vue').WatchStopHandle;
    submit: (options?: {
        fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
        superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
    } | undefined) => Promise<boolean>;
    validate: (value?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, options?: {
        fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
        superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
    } | undefined) => Promise<boolean>;
    wrappers: Map<string, InjectedFormWrapperData<Schema>>;
    VvForm: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        continuousValidation: {
            type: BooleanConstructor;
            default: boolean;
        };
        modelValue: {
            type: ObjectConstructor;
            default: () => {};
        };
        readonly: {
            type: BooleanConstructor;
            default: boolean | undefined;
        };
        tag: {
            type: StringConstructor;
            default: string;
        };
        template: {
            type: import('vue').PropType<FormTemplate<Schema, Type>>;
            default: undefined;
        };
        superRefine: {
            type: import('vue').PropType<(arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>>;
            default: undefined;
        };
        validateFields: {
            type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>[]>;
            default: undefined;
        };
    }>, {
        clear: () => void;
        errors: Readonly<import('vue').Ref<import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined, import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined>>;
        formData: import('vue').Ref<(undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined>;
        ignoreUpdates: import('@vueuse/shared').IgnoredUpdater;
        invalid: import('vue').ComputedRef<boolean>;
        isReadonly: import('vue').Ref<boolean, boolean>;
        reset: () => void;
        status: Readonly<import('vue').Ref<import('./enums').FormStatus | undefined, import('./enums').FormStatus | undefined>>;
        stopUpdatesWatch: import('vue').WatchStopHandle;
        submit: () => Promise<boolean>;
        validate: (value?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, options?: {
            fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
            superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
        } | undefined) => Promise<boolean>;
        wrappers: Map<string, InjectedFormWrapperData<Schema>>;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("invalid" | "valid" | "reset" | "submit" | "update:modelValue" | "update:readonly")[], "invalid" | "valid" | "reset" | "submit" | "update:modelValue" | "update:readonly", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        continuousValidation: {
            type: BooleanConstructor;
            default: boolean;
        };
        modelValue: {
            type: ObjectConstructor;
            default: () => {};
        };
        readonly: {
            type: BooleanConstructor;
            default: boolean | undefined;
        };
        tag: {
            type: StringConstructor;
            default: string;
        };
        template: {
            type: import('vue').PropType<FormTemplate<Schema, Type>>;
            default: undefined;
        };
        superRefine: {
            type: import('vue').PropType<(arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>>;
            default: undefined;
        };
        validateFields: {
            type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>[]>;
            default: undefined;
        };
    }>> & Readonly<{
        onInvalid?: ((...args: any[]) => any) | undefined;
        onValid?: ((...args: any[]) => any) | undefined;
        onReset?: ((...args: any[]) => any) | undefined;
        onSubmit?: ((...args: any[]) => any) | undefined;
        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
        "onUpdate:readonly"?: ((...args: any[]) => any) | undefined;
    }>, {
        readonly: boolean;
        superRefine: (arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>;
        tag: string;
        template: FormTemplate<Schema, Type>;
        continuousValidation: boolean;
        modelValue: Record<string, any>;
        validateFields: Path<import('./types').InferSchema<Schema>>[];
    }, import('vue').SlotsType<{
        default: {
            errors: import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined;
            formData: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined;
            invalid: import('vue').UnwrapRef<import('vue').ComputedRef<boolean>>;
            readonly: import('vue').UnwrapRef<import('vue').Ref<boolean, boolean>>;
            status: import('vue').UnwrapRef<Readonly<import('vue').Ref<import('./enums').FormStatus | undefined, import('./enums').FormStatus | undefined>>>;
            wrappers: Map<string, InjectedFormWrapperData<Schema>>;
            clear: () => void;
            ignoreUpdates: import('@vueuse/shared').IgnoredUpdater;
            reset: () => void;
            stopUpdatesWatch: import('vue').WatchStopHandle;
            submit: (options?: {
                fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
                superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
            } | undefined) => Promise<boolean>;
            validate: (value?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, options?: {
                fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
                superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
            } | undefined) => Promise<boolean>;
        };
    }>, {}, {}, "invalid" | "valid" | "reset" | "status" | "readonly" | "clear" | "errors" | "validate" | "submit" | "tag" | "template", import('vue').ComponentProvideOptions, true, {}, any>;
    VvFormField: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        type: {
            type: import('vue').PropType<`${import('./enums').FormFieldType}`>;
            validator: (value: import('./enums').FormFieldType) => boolean;
            default: import('./enums').FormFieldType;
        };
        is: {
            type: import('vue').PropType<import('vue').Component | string>;
            default: undefined;
        };
        name: {
            type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>>;
            required: true;
        };
        props: {
            type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
            default: () => {};
        };
        showValid: {
            type: BooleanConstructor;
            default: boolean;
        };
        defaultValue: {
            type: (ArrayConstructor | NumberConstructor | ObjectConstructor | BooleanConstructor | StringConstructor)[];
            default: undefined;
        };
        lazyLoad: {
            type: BooleanConstructor;
            default: boolean;
        };
        readonly: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>, {
        component: import('vue').ComputedRef<{
            new (...args: any[]): any;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } | import('vue').ConcreteComponent>;
        hasProps: import('vue').ComputedRef<{
            name: {} | ([{
                type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>>;
                required: true;
            }] extends [import('vue').Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? import('@vue/shared').IfAny<V, V, D> : V : V : {
                type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>>;
                required: true;
            });
            invalid: boolean;
            valid: boolean | undefined;
            type: import('./enums').FormFieldType | undefined;
            invalidLabel: string[] | undefined;
            modelValue: unknown;
            readonly: boolean;
            'onUpdate:modelValue': (value: unknown) => void;
        }>;
        invalid: import('vue').ComputedRef<boolean>;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("invalid" | "valid" | "update:modelValue" | "update:formData")[], "invalid" | "valid" | "update:modelValue" | "update:formData", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        type: {
            type: import('vue').PropType<`${import('./enums').FormFieldType}`>;
            validator: (value: import('./enums').FormFieldType) => boolean;
            default: import('./enums').FormFieldType;
        };
        is: {
            type: import('vue').PropType<import('vue').Component | string>;
            default: undefined;
        };
        name: {
            type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>>;
            required: true;
        };
        props: {
            type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
            default: () => {};
        };
        showValid: {
            type: BooleanConstructor;
            default: boolean;
        };
        defaultValue: {
            type: (ArrayConstructor | NumberConstructor | ObjectConstructor | BooleanConstructor | StringConstructor)[];
            default: undefined;
        };
        lazyLoad: {
            type: BooleanConstructor;
            default: boolean;
        };
        readonly: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{
        onInvalid?: ((...args: any[]) => any) | undefined;
        onValid?: ((...args: any[]) => any) | undefined;
        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
        "onUpdate:formData"?: ((...args: any[]) => any) | undefined;
    }>, {
        type: "number" | "text" | "email" | "password" | "tel" | "url" | "search" | "date" | "time" | "datetime-local" | "month" | "week" | "color" | "select" | "checkbox" | "radio" | "textarea" | "radioGroup" | "checkboxGroup" | "combobox" | "custom";
        readonly: boolean;
        props: [{
            type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
            default: () => {};
        }] extends [import('vue').Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? import('@vue/shared').IfAny<V, V, D> : V : V : {
            type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
            default: () => {};
        };
        is: string | import('vue').Component;
        showValid: boolean;
        defaultValue: string | number | boolean | unknown[] | Record<string, any>;
        lazyLoad: boolean;
    }, import('vue').SlotsType<{
        [key: string]: any;
        default: {
            errors: import('vue').DeepReadonly<import('./types').InferFormattedError<Schema> | undefined>;
            formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined;
            formErrors?: import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined;
            invalid: boolean;
            invalidLabel?: string[];
            modelValue: any;
            readonly: boolean;
            onUpdate: (value: unknown) => void;
            submit?: InjectedFormData<Schema_1, Type_1>["submit"];
            validate?: ((formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, options?: {
                fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
                superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
            } | undefined) => Promise<boolean>) | undefined;
        };
    }>, {}, {}, "invalid" | "type" | "errors" | "component" | "hasProps" | "invalidLabel" | "is", import('vue').ComponentProvideOptions, true, {}, any>;
    VvFormFieldsGroup: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        is: {
            type: import('vue').PropType<import('vue').Component | string>;
            default: undefined;
        };
        names: {
            type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>[] | Record<string, Path<import('./types').InferSchema<Schema>>>>;
            required: true;
        };
        props: {
            type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
            default: () => {};
        };
        showValid: {
            type: BooleanConstructor;
            default: boolean;
        };
        defaultValues: {
            type: import('vue').PropType<Record<Path<import('./types').InferSchema<Schema>>, any>>;
            default: undefined;
        };
        readonly: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>, {
        component: import('vue').ComputedRef<{
            render(): import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
                [key: string]: any;
            }>[];
        }>;
        hasProps: import('vue').ComputedRef<{
            modelValue: Record<string, any>;
            names: {};
            invalid: boolean;
            invalids: Record<string, boolean>;
            valid: boolean | undefined;
            invalidLabels: Record<string, string[]> | undefined;
            readonly: boolean;
        }>;
        invalid: import('vue').ComputedRef<boolean>;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("invalid" | "valid" | "update:modelValue" | "update:formData")[], "invalid" | "valid" | "update:modelValue" | "update:formData", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        is: {
            type: import('vue').PropType<import('vue').Component | string>;
            default: undefined;
        };
        names: {
            type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>[] | Record<string, Path<import('./types').InferSchema<Schema>>>>;
            required: true;
        };
        props: {
            type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
            default: () => {};
        };
        showValid: {
            type: BooleanConstructor;
            default: boolean;
        };
        defaultValues: {
            type: import('vue').PropType<Record<Path<import('./types').InferSchema<Schema>>, any>>;
            default: undefined;
        };
        readonly: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{
        onInvalid?: ((...args: any[]) => any) | undefined;
        onValid?: ((...args: any[]) => any) | undefined;
        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
        "onUpdate:formData"?: ((...args: any[]) => any) | undefined;
    }>, {
        readonly: boolean;
        props: [{
            type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
            default: () => {};
        }] extends [import('vue').Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? import('@vue/shared').IfAny<V, V, D> : V : V : {
            type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
            default: () => {};
        };
        is: string | import('vue').Component;
        showValid: boolean;
        defaultValues: [{
            type: import('vue').PropType<Record<Path<import('./types').InferSchema<Schema>>, any>>;
            default: undefined;
        }] extends [import('vue').Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? import('@vue/shared').IfAny<V, V, D> : V : V : {
            type: import('vue').PropType<Record<Path<import('./types').InferSchema<Schema>>, any>>;
            default: undefined;
        };
    }, import('vue').SlotsType<{
        [key: string]: any;
        default: {
            errors?: Record<Path<import('./types').InferSchema<Schema>>, import('./types').InferFormattedError<Schema>> | undefined;
            formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined;
            formErrors?: import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined;
            invalid: boolean;
            invalids: Record<string, boolean>;
            invalidLabels?: Record<string, string[]>;
            modelValue: Record<string, any>;
            onUpdate: (value: Record<string, any>) => void;
            onUpdateField: (name: string, value: any) => void;
            readonly: boolean;
            submit?: InjectedFormData<Schema_2, Type_2>["submit"];
            validate?: ((formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, options?: {
                fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
                superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
            } | undefined) => Promise<boolean>) | undefined;
        };
    }>, {}, {}, "invalid" | "errors" | "component" | "hasProps" | "is" | "invalidLabels", import('vue').ComponentProvideOptions, true, {}, any>;
    VvFormTemplate: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        schema: {
            type: import('vue').PropType<FormTemplate<Schema, Type>>;
            required: true;
        };
        scope: {
            type: import('vue').PropType<Record<string, unknown>>;
            default: () => {};
        };
    }>, (() => (import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
        [key: string]: any;
    }> | import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
        [key: string]: any;
    }>[] | undefined)[]) | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        schema: {
            type: import('vue').PropType<FormTemplate<Schema, Type>>;
            required: true;
        };
        scope: {
            type: import('vue').PropType<Record<string, unknown>>;
            default: () => {};
        };
    }>> & Readonly<{}>, {
        scope: Record<string, unknown>;
    }, import('vue').SlotsType<{
        default: {
            errors?: import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined;
            formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined;
            invalid: boolean;
            status?: import('./enums').FormStatus;
            submit?: InjectedFormData<Schema_3, Type_3>["submit"];
            validate?: ((formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, options?: {
                fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
                superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
            } | undefined) => Promise<boolean>) | undefined;
            clear?: InjectedFormData<Schema_3, Type_3>["clear"];
            reset?: InjectedFormData<Schema_3, Type_3>["reset"];
        };
    }>, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    VvFormWrapper: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        name: {
            type: StringConstructor;
            required: true;
        };
        tag: {
            type: StringConstructor;
            default: undefined;
        };
        readonly: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>, {
        errors: Readonly<import('vue').Ref<import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined, import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined>> | undefined;
        fields: import('vue').Ref<Map<string, Path<import('./types').InferSchema<Schema>>>, Map<string, Path<import('./types').InferSchema<Schema>>>>;
        fieldsErrors: import('vue').Ref<Map<string, import('./types').InferFormattedError<Schema>>, Map<string, import('./types').InferFormattedError<Schema>>>;
        formData: import('vue').Ref<(undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined> | undefined;
        invalid: import('vue').ComputedRef<boolean>;
        readonly: import('vue').ComputedRef<boolean>;
        clear: (() => void) | undefined;
        reset: (() => void) | undefined;
        submit: (() => Promise<boolean>) | undefined;
        validate: ((formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, options?: {
            fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
            superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
        } | undefined) => Promise<boolean>) | undefined;
        validateWrapper: () => Promise<boolean>;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("invalid" | "valid")[], "invalid" | "valid", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        name: {
            type: StringConstructor;
            required: true;
        };
        tag: {
            type: StringConstructor;
            default: undefined;
        };
        readonly: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>> & Readonly<{
        onInvalid?: ((...args: any[]) => any) | undefined;
        onValid?: ((...args: any[]) => any) | undefined;
    }>, {
        readonly: boolean;
        tag: string;
    }, import('vue').SlotsType<{
        default: {
            errors?: import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined;
            fieldsErrors: Map<string, import('./types').InferFormattedError<Schema>>;
            formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined;
            formErrors?: import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined;
            invalid: boolean;
            readonly: boolean;
            clear?: InjectedFormData<Schema_4, Type_4>["clear"];
            reset?: InjectedFormData<Schema_4, Type_4>["reset"];
            submit?: InjectedFormData<Schema_4, Type_4>["submit"];
            validate?: ((formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, options?: {
                fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
                superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
            } | undefined) => Promise<boolean>) | undefined;
            validateWrapper?: (() => Promise<boolean>) | undefined;
        };
    }>, {}, {}, "invalid" | "reset" | "readonly" | "clear" | "errors" | "validate" | "submit" | "tag" | "formData" | "fields" | "fieldsErrors" | "validateWrapper", import('vue').ComponentProvideOptions, true, {}, any>;
};
export declare const pluginInjectionKey: InjectionKey<FormPluginOptions>;
export declare function createForm(options: FormPluginOptions): Plugin & Partial<ReturnType<typeof useForm>>;
export declare function useForm<Schema extends FormSchema, Type>(schema: Schema, options?: FormComposableOptions<Schema, Type>): ReturnType<typeof _formType<Schema, Type>>;
export { FormFieldType } from './enums';
export { defaultObjectBySchema } from './utils';
type FormComponent = ReturnType<typeof defineForm>;
type FormWrapperComponent = ReturnType<typeof defineFormWrapper>;
type FormFieldComponent = ReturnType<typeof defineFormField>;
type FormFieldsGroupComponent = ReturnType<typeof defineFormFieldsGroup>;
type FormTemplateComponent = ReturnType<typeof defineFormFieldsGroup>;
export type { FormComponent, FormComposableOptions, FormFieldComponent, FormFieldsGroupComponent, FormPluginOptions, FormSchema, FormTemplate, FormTemplateComponent, FormTemplateItem, FormWrapperComponent, InjectedFormData, InjectedFormFieldData, InjectedFormWrapperData, Path, PathValue, };
/**
 * @deprecated Use `useForm()` instead
 */
export declare function formType<Schema extends FormSchema, Type>(schema: Schema, options?: FormComposableOptions<Schema, Type>): {
    clear: () => void;
    errors: import('vue').Ref<import('./types').InferFormattedError<Schema> | undefined, import('./types').InferFormattedError<Schema> | undefined>;
    formData: import('vue').Ref<(undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined>;
    formFieldInjectionKey: InjectionKey<InjectedFormFieldData<Schema>>;
    formInjectionKey: InjectionKey<InjectedFormData<Schema, Type>>;
    formWrapperInjectionKey: InjectionKey<InjectedFormWrapperData<Schema>>;
    ignoreUpdates: import('@vueuse/shared').IgnoredUpdater;
    invalid: import('vue').ComputedRef<boolean>;
    readonly: import('vue').Ref<boolean, boolean>;
    reset: () => void;
    status: import('vue').Ref<import('./enums').FormStatus | undefined, import('./enums').FormStatus | undefined>;
    stopUpdatesWatch: import('vue').WatchStopHandle;
    submit: (options?: {
        fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
        superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
    } | undefined) => Promise<boolean>;
    validate: (value?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, options?: {
        fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
        superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
    } | undefined) => Promise<boolean>;
    wrappers: Map<string, InjectedFormWrapperData<Schema>>;
    VvForm: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        continuousValidation: {
            type: BooleanConstructor;
            default: boolean;
        };
        modelValue: {
            type: ObjectConstructor;
            default: () => {};
        };
        readonly: {
            type: BooleanConstructor;
            default: boolean | undefined;
        };
        tag: {
            type: StringConstructor;
            default: string;
        };
        template: {
            type: import('vue').PropType<FormTemplate<Schema, Type>>;
            default: undefined;
        };
        superRefine: {
            type: import('vue').PropType<(arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>>;
            default: undefined;
        };
        validateFields: {
            type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>[]>;
            default: undefined;
        };
    }>, {
        clear: () => void;
        errors: Readonly<import('vue').Ref<import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined, import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined>>;
        formData: import('vue').Ref<(undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined>;
        ignoreUpdates: import('@vueuse/shared').IgnoredUpdater;
        invalid: import('vue').ComputedRef<boolean>;
        isReadonly: import('vue').Ref<boolean, boolean>;
        reset: () => void;
        status: Readonly<import('vue').Ref<import('./enums').FormStatus | undefined, import('./enums').FormStatus | undefined>>;
        stopUpdatesWatch: import('vue').WatchStopHandle;
        submit: () => Promise<boolean>;
        validate: (value?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, options?: {
            fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
            superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
        } | undefined) => Promise<boolean>;
        wrappers: Map<string, InjectedFormWrapperData<Schema>>;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("invalid" | "valid" | "reset" | "submit" | "update:modelValue" | "update:readonly")[], "invalid" | "valid" | "reset" | "submit" | "update:modelValue" | "update:readonly", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        continuousValidation: {
            type: BooleanConstructor;
            default: boolean;
        };
        modelValue: {
            type: ObjectConstructor;
            default: () => {};
        };
        readonly: {
            type: BooleanConstructor;
            default: boolean | undefined;
        };
        tag: {
            type: StringConstructor;
            default: string;
        };
        template: {
            type: import('vue').PropType<FormTemplate<Schema, Type>>;
            default: undefined;
        };
        superRefine: {
            type: import('vue').PropType<(arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>>;
            default: undefined;
        };
        validateFields: {
            type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>[]>;
            default: undefined;
        };
    }>> & Readonly<{
        onInvalid?: ((...args: any[]) => any) | undefined;
        onValid?: ((...args: any[]) => any) | undefined;
        onReset?: ((...args: any[]) => any) | undefined;
        onSubmit?: ((...args: any[]) => any) | undefined;
        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
        "onUpdate:readonly"?: ((...args: any[]) => any) | undefined;
    }>, {
        readonly: boolean;
        superRefine: (arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>;
        tag: string;
        template: FormTemplate<Schema, Type>;
        continuousValidation: boolean;
        modelValue: Record<string, any>;
        validateFields: Path<import('./types').InferSchema<Schema>>[];
    }, import('vue').SlotsType<{
        default: {
            errors: import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined;
            formData: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined;
            invalid: import('vue').UnwrapRef<import('vue').ComputedRef<boolean>>;
            readonly: import('vue').UnwrapRef<import('vue').Ref<boolean, boolean>>;
            status: import('vue').UnwrapRef<Readonly<import('vue').Ref<import('./enums').FormStatus | undefined, import('./enums').FormStatus | undefined>>>;
            wrappers: Map<string, InjectedFormWrapperData<Schema>>;
            clear: () => void;
            ignoreUpdates: import('@vueuse/shared').IgnoredUpdater;
            reset: () => void;
            stopUpdatesWatch: import('vue').WatchStopHandle;
            submit: (options?: {
                fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
                superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
            } | undefined) => Promise<boolean>;
            validate: (value?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, options?: {
                fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
                superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
            } | undefined) => Promise<boolean>;
        };
    }>, {}, {}, "invalid" | "valid" | "reset" | "status" | "readonly" | "clear" | "errors" | "validate" | "submit" | "tag" | "template", import('vue').ComponentProvideOptions, true, {}, any>;
    VvFormField: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        type: {
            type: import('vue').PropType<`${import('./enums').FormFieldType}`>;
            validator: (value: import('./enums').FormFieldType) => boolean;
            default: import('./enums').FormFieldType;
        };
        is: {
            type: import('vue').PropType<import('vue').Component | string>;
            default: undefined;
        };
        name: {
            type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>>;
            required: true;
        };
        props: {
            type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
            default: () => {};
        };
        showValid: {
            type: BooleanConstructor;
            default: boolean;
        };
        defaultValue: {
            type: (ArrayConstructor | NumberConstructor | ObjectConstructor | BooleanConstructor | StringConstructor)[];
            default: undefined;
        };
        lazyLoad: {
            type: BooleanConstructor;
            default: boolean;
        };
        readonly: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>, {
        component: import('vue').ComputedRef<{
            new (...args: any[]): any;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } | import('vue').ConcreteComponent>;
        hasProps: import('vue').ComputedRef<{
            name: {} | ([{
                type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>>;
                required: true;
            }] extends [import('vue').Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? import('@vue/shared').IfAny<V, V, D> : V : V : {
                type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>>;
                required: true;
            });
            invalid: boolean;
            valid: boolean | undefined;
            type: import('./enums').FormFieldType | undefined;
            invalidLabel: string[] | undefined;
            modelValue: unknown;
            readonly: boolean;
            'onUpdate:modelValue': (value: unknown) => void;
        }>;
        invalid: import('vue').ComputedRef<boolean>;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("invalid" | "valid" | "update:modelValue" | "update:formData")[], "invalid" | "valid" | "update:modelValue" | "update:formData", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        type: {
            type: import('vue').PropType<`${import('./enums').FormFieldType}`>;
            validator: (value: import('./enums').FormFieldType) => boolean;
            default: import('./enums').FormFieldType;
        };
        is: {
            type: import('vue').PropType<import('vue').Component | string>;
            default: undefined;
        };
        name: {
            type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>>;
            required: true;
        };
        props: {
            type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
            default: () => {};
        };
        showValid: {
            type: BooleanConstructor;
            default: boolean;
        };
        defaultValue: {
            type: (ArrayConstructor | NumberConstructor | ObjectConstructor | BooleanConstructor | StringConstructor)[];
            default: undefined;
        };
        lazyLoad: {
            type: BooleanConstructor;
            default: boolean;
        };
        readonly: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{
        onInvalid?: ((...args: any[]) => any) | undefined;
        onValid?: ((...args: any[]) => any) | undefined;
        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
        "onUpdate:formData"?: ((...args: any[]) => any) | undefined;
    }>, {
        type: "number" | "text" | "email" | "password" | "tel" | "url" | "search" | "date" | "time" | "datetime-local" | "month" | "week" | "color" | "select" | "checkbox" | "radio" | "textarea" | "radioGroup" | "checkboxGroup" | "combobox" | "custom";
        readonly: boolean;
        props: [{
            type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
            default: () => {};
        }] extends [import('vue').Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? import('@vue/shared').IfAny<V, V, D> : V : V : {
            type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
            default: () => {};
        };
        is: string | import('vue').Component;
        showValid: boolean;
        defaultValue: string | number | boolean | unknown[] | Record<string, any>;
        lazyLoad: boolean;
    }, import('vue').SlotsType<{
        [key: string]: any;
        default: {
            errors: import('vue').DeepReadonly<import('./types').InferFormattedError<Schema> | undefined>;
            formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined;
            formErrors?: import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined;
            invalid: boolean;
            invalidLabel?: string[];
            modelValue: any;
            readonly: boolean;
            onUpdate: (value: unknown) => void;
            submit?: InjectedFormData<Schema_1, Type_1>["submit"];
            validate?: ((formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, options?: {
                fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
                superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
            } | undefined) => Promise<boolean>) | undefined;
        };
    }>, {}, {}, "invalid" | "type" | "errors" | "component" | "hasProps" | "invalidLabel" | "is", import('vue').ComponentProvideOptions, true, {}, any>;
    VvFormFieldsGroup: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        is: {
            type: import('vue').PropType<import('vue').Component | string>;
            default: undefined;
        };
        names: {
            type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>[] | Record<string, Path<import('./types').InferSchema<Schema>>>>;
            required: true;
        };
        props: {
            type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
            default: () => {};
        };
        showValid: {
            type: BooleanConstructor;
            default: boolean;
        };
        defaultValues: {
            type: import('vue').PropType<Record<Path<import('./types').InferSchema<Schema>>, any>>;
            default: undefined;
        };
        readonly: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>, {
        component: import('vue').ComputedRef<{
            render(): import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
                [key: string]: any;
            }>[];
        }>;
        hasProps: import('vue').ComputedRef<{
            modelValue: Record<string, any>;
            names: {};
            invalid: boolean;
            invalids: Record<string, boolean>;
            valid: boolean | undefined;
            invalidLabels: Record<string, string[]> | undefined;
            readonly: boolean;
        }>;
        invalid: import('vue').ComputedRef<boolean>;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("invalid" | "valid" | "update:modelValue" | "update:formData")[], "invalid" | "valid" | "update:modelValue" | "update:formData", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        is: {
            type: import('vue').PropType<import('vue').Component | string>;
            default: undefined;
        };
        names: {
            type: import('vue').PropType<Path<import('./types').InferSchema<Schema>>[] | Record<string, Path<import('./types').InferSchema<Schema>>>>;
            required: true;
        };
        props: {
            type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
            default: () => {};
        };
        showValid: {
            type: BooleanConstructor;
            default: boolean;
        };
        defaultValues: {
            type: import('vue').PropType<Record<Path<import('./types').InferSchema<Schema>>, any>>;
            default: undefined;
        };
        readonly: {
            type: BooleanConstructor;
            default: undefined;
        };
    }>> & Readonly<{
        onInvalid?: ((...args: any[]) => any) | undefined;
        onValid?: ((...args: any[]) => any) | undefined;
        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
        "onUpdate:formData"?: ((...args: any[]) => any) | undefined;
    }>, {
        readonly: boolean;
        props: [{
            type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
            default: () => {};
        }] extends [import('vue').Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? import('@vue/shared').IfAny<V, V, D> : V : V : {
            type: import('vue').PropType<Partial<import('./types').InferSchema<Schema> | ((formData?: import('vue').Ref<ObjectConstructor>) => Partial<import('./types').InferSchema<Schema>> | undefined) | undefined>>;
            default: () => {};
        };
        is: string | import('vue').Component;
        showValid: boolean;
        defaultValues: [{
            type: import('vue').PropType<Record<Path<import('./types').InferSchema<Schema>>, any>>;
            default: undefined;
        }] extends [import('vue').Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? import('@vue/shared').IfAny<V, V, D> : V : V : {
            type: import('vue').PropType<Record<Path<import('./types').InferSchema<Schema>>, any>>;
            default: undefined;
        };
    }, import('vue').SlotsType<{
        [key: string]: any;
        default: {
            errors?: Record<Path<import('./types').InferSchema<Schema>>, import('./types').InferFormattedError<Schema>> | undefined;
            formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined;
            formErrors?: import('vue').DeepReadonly<import('./types').InferFormattedError<Schema>> | undefined;
            invalid: boolean;
            invalids: Record<string, boolean>;
            invalidLabels?: Record<string, string[]>;
            modelValue: Record<string, any>;
            onUpdate: (value: Record<string, any>) => void;
            onUpdateField: (name: string, value: any) => void;
            readonly: boolean;
            submit?: InjectedFormData<Schema_2, Type_2>["submit"];
            validate?: ((formData?: (undefined extends Type ? Partial<import('./types').InferSchema<Schema>> : Type) | undefined, options?: {
                fields?: Set<Path<import('./types').InferSchema<Schema>>> | undefined;
                superRefine?: ((arg: import('./types').InferSchema<Schema>, ctx: import('./types').RefinementCtx<Schema>) => void | Promise<void>) | undefined;
            } | undefined) => Promise<boolean>) | undefined;
        };
    }>, {}, {}, "invalid" | "errors" | "component" | "hasProps" | "is" | "invalidLabels", import('vue').ComponentProvideOptions, true, {}, any>;
    VvFormTemplate: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        schema: {
            type: import('vue').PropType<FormTemplate<Schema, Type>>;
            required: true;
        };
        scope: {
            type: import('vue').PropType<Record<string, unknown>>;
            default: () => {};
        };
    }>, (() => (import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
        [key: string]: any;
    }> | import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
        [key: string]: any;
    }>[] | undefined)[]) | undefined, {}, {}, {}, import('v