import { RuleItem as RuleItem$1, ValidateMessages as ValidateMessages$1 } from 'async-validator';
import * as vue from 'vue';
import { ComputedRef, UnwrapRef, PropType, Plugin, VNode } from 'vue';

type NamePath = string | number | (string | number)[];

type ValidateTrigger = "change" | "blur";
interface RuleItem extends RuleItem$1 {
    trigger?: ValidateTrigger | ValidateTrigger[];
}
type Rule = RuleItem | RuleItem[];
type Rules = Record<string, Rule>;
interface ValidateOption {
    trigger: ValidateTrigger | ValidateTrigger[];
}
interface ValidateError {
    name: NamePath;
    messages: string[];
}
interface ValidateMessages extends ValidateMessages$1 {
}

interface FieldMeta {
    /**
     * Raw value before being transformed
     */
    rawValue: any;
    /**
     * Value after being transformed by valueTransformer()
     */
    transformedValue: any;
    error?: ValidateError;
    dirty: boolean;
    touched: boolean;
    name?: NamePath;
    id: string;
    formName: string;
}
interface FormItemValueTransformer<In = any, Out = any> {
    in: (value: In, formValues: {
        [key: string]: any;
    }) => Out;
    out: (value: Out, formValues: {
        [key: string]: any;
    }) => In;
}
interface FormItemProps {
    label?: string;
    name?: string | number | (string | number)[];
    formItem?: FormItemInstance;
    defaultValue?: any;
    getValueFromChangeEvent?: (event: any) => any;
    valueTransformer?: FormItemValueTransformer;
    validateTrigger?: ValidateTrigger | ValidateTrigger[];
    rules?: Rule;
    requiredMark?: string | boolean;
    validateFirst?: boolean;
}
interface FormItemEmitter {
    (event: "change", value: any, form: FormInstance): void;
}
interface FormItemInstance {
    __IS_FAKE__?: boolean;
    meta: FieldMeta;
    requiredMarkString: ComputedRef<string>;
    handleChange: (event: any) => void;
    handleBlur: () => void;
    registerFormField: (formInstance?: FormInstance) => void;
    unRegisterFormField: () => void;
    validate: (options?: ValidateOption) => Promise<{
        value?: any;
        error?: ValidateError;
    }>;
    clearValidate: () => void;
}
interface FormItemSlotProps {
    value: FieldMeta["transformedValue"];
    rawValue: FieldMeta["rawValue"];
    error: FieldMeta["error"];
    handleChange: FormItemInstance["handleChange"];
    form: FormInstance;
}
interface FormItemSlotErrorsProps {
    errors: ValidateError | undefined;
    form: FormInstance;
    formItem: FormItemEmitter;
}
interface FormItemSlotExtraProps {
    form: FormInstance;
    formItem: FormItemInstance;
}

interface FormMeta<Values = any> {
    name: string;
    values: Values;
    errors: ValidateError[];
    dirty: boolean;
}
interface FormField {
    name: ComputedRef<NamePath>;
    id: ComputedRef<string>;
    validate: FormItemInstance["validate"];
    clearValidate: () => void;
    reset: () => void;
    markAsDirty: () => void;
    defaultValue: any;
    value: ComputedRef<any>;
    error: ComputedRef<ValidateError | undefined>;
    dirty: ComputedRef<boolean>;
}
interface FormSettings<Values extends object = any> {
    name?: string;
    form?: FormInstance;
    initialValues?: Values;
    enableReinitialize?: boolean;
    rules?: Rules;
    validateTrigger?: ValidateTrigger | ValidateTrigger[];
    validateMessages?: ValidateMessages;
    classPrefix?: string;
    preserveValues?: boolean;
}
interface FormEmitter {
    (event: "submit", values: any): void;
    (event: "change", values: any): void;
    (event: "reset"): void;
    (event: "error", errors: any): void;
}
interface FormSlotProps {
    values: FormInstance["meta"]["values"];
    errors: FormInstance["meta"]["errors"];
    dirty: FormInstance["meta"]["dirty"];
    submit: FormInstance["submit"];
    reset: FormInstance["reset"];
    validate: FormInstance["validate"];
    getFieldValue: FormInstance["getFieldValue"];
    setFieldValue: FormInstance["setFieldValue"];
    isDirty: FormInstance["isDirty"];
}
interface FormInstance<Values extends object = any> {
    __IS_FAKE__?: boolean;
    meta: FormMeta;
    validateTrigger?: ValidateTrigger | ValidateTrigger[];
    rules?: Rules;
    validateMessages?: ValidateMessages;
    classPrefix: string;
    getFieldValue(name: NamePath): any;
    setFieldValue(name: NamePath, value: any): void;
    validate(name?: string | NamePath[], options?: ValidateOption): Promise<{
        values?: any;
        errors?: ValidateError[];
    }>;
    clearValidate(name?: NamePath): void;
    submit: <S extends FormSubmitCallback<Values> | undefined = undefined, E extends FormErrorCallback | undefined = undefined>(onSuccess?: FormSubmitCallback<Values> | S, onError?: FormErrorCallback | E) => S extends FormSubmitCallback<Values> ? void : E extends FormErrorCallback ? void : Promise<{
        values?: Values;
        errors?: ValidateError[];
    }>;
    reset: (values?: Values) => void;
    isDirty: (name?: NamePath) => boolean;
    addField(field: FormField): void;
    removeField(namePath: NamePath): void;
    updateSettings(settings: Partial<FormSettings>): void;
}
type FormSubmitCallback<Values = any> = (values: Values) => void;
type FormErrorCallback = (errors: ValidateError[]) => void;

interface FormListProps extends Omit<FormItemProps, "formItem"> {
    defaultValue?: any[];
    formList?: FormListInstance;
}
interface FormListField {
    key: string;
    index: number;
    getNamePath: (name: NamePath) => string;
}
interface FormListInstance extends Omit<FormItemInstance, "handleBlur" | "handleChange"> {
    listValues: ComputedRef<any[]>;
    namePrefix: ComputedRef<(string | number)[]>;
    fields: ComputedRef<FormListField[]>;
    getNamePath(index: number, name: NamePath): string;
    getErrors(index?: number): ValidateError[];
    hasError(index: number): boolean;
    add(newValue?: any): void;
    insert(index: number, newValue?: any): void;
    unshift(value?: any): void;
    pop(): any;
    shift(): any;
    remove(index: number): void;
    removeByKey(key: string, value: any): void;
    replace(index: number, newValue: any): void;
    swap(firstIndex: number, secondIndex: number): void;
    move(fromIndex: number, toIndex: number): void;
}
interface FormListSlotProps extends UnwrapRef<FormListInstance> {
    form: FormInstance;
}
interface FormListSlotErrorsProps {
    errors: ValidateError | undefined;
    form: FormInstance;
    formList: FormListInstance;
}
interface FormListSlotExtraProps {
    form: FormInstance;
    formList: FormListInstance;
}

interface PluginOptions {
    validateMessages?: ValidateMessages;
    colon?: boolean;
    requiredMark?: string;
}

declare const EzForm: {
    new (...args: any[]): {
        $: vue.ComponentInternalInstance;
        $data: {};
        $props: {
            readonly classPrefix?: string | undefined;
            readonly preserveValues?: boolean | undefined;
            readonly name?: string | undefined;
            readonly form?: FormInstance<any> | undefined;
            readonly initialValues?: Record<string, any> | undefined;
            readonly enableReinitialize?: boolean | undefined;
            readonly rules?: Rules | undefined;
            readonly validateTrigger?: ValidateTrigger | ValidateTrigger[] | undefined;
            readonly validateMessages?: ValidateMessages | undefined;
            readonly onSubmit?: ((values: any) => void) | undefined;
            readonly onChange?: ((values: any) => void) | undefined;
            readonly onError?: ((errors: ValidateError[]) => void) | undefined;
            readonly onReset?: (() => void) | undefined;
            class?: unknown;
            style?: unknown;
            key?: string | number | symbol | undefined;
            ref?: vue.VNodeRef | undefined;
            ref_for?: boolean | undefined;
            ref_key?: string | undefined;
            onVnodeBeforeMount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
            onVnodeMounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
            onVnodeBeforeUpdate?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
            onVnodeUpdated?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
            onVnodeBeforeUnmount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
            onVnodeUnmounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
        };
        $attrs: {
            [x: string]: unknown;
        };
        $refs: {
            [x: string]: unknown;
        };
        $slots: Readonly<{
            [name: string]: vue.Slot<any> | undefined;
        }>;
        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
        $emit: (event: string, ...args: any[]) => void;
        $el: any;
        $options: vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
            readonly name: {
                readonly required: false;
                readonly type: vue.PropType<string>;
            };
            readonly form: {
                readonly required: false;
                readonly type: vue.PropType<FormInstance<any>>;
            };
            readonly initialValues: {
                readonly required: false;
                readonly type: vue.PropType<Record<string, any>>;
            };
            readonly enableReinitialize: {
                readonly required: false;
                readonly type: vue.PropType<boolean>;
            };
            readonly rules: {
                readonly required: false;
                readonly type: vue.PropType<Rules>;
            };
            readonly validateTrigger: {
                readonly required: false;
                readonly type: vue.PropType<ValidateTrigger | ValidateTrigger[]>;
            };
            readonly validateMessages: {
                readonly required: false;
                readonly type: vue.PropType<ValidateMessages>;
            };
            readonly classPrefix: {
                readonly required: false;
                readonly type: vue.PropType<string>;
                readonly default: "ez";
            };
            readonly preserveValues: {
                readonly required: false;
                readonly type: vue.PropType<boolean>;
                readonly default: true;
            };
            readonly onSubmit: {
                readonly required: false;
                readonly type: vue.PropType<(values: any) => void>;
            };
            readonly onChange: {
                readonly required: false;
                readonly type: vue.PropType<(values: any) => void>;
            };
            readonly onError: {
                readonly required: false;
                readonly type: vue.PropType<(errors: ValidateError[]) => void>;
            };
            readonly onReset: {
                readonly required: false;
                readonly type: vue.PropType<() => void>;
            };
        }>>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
            readonly classPrefix: string;
            readonly preserveValues: boolean;
        }, {}, string, {}> & {
            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
            created?: ((() => void) | (() => void)[]) | undefined;
            beforeMount?: ((() => void) | (() => void)[]) | undefined;
            mounted?: ((() => void) | (() => void)[]) | undefined;
            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
            updated?: ((() => void) | (() => void)[]) | undefined;
            activated?: ((() => void) | (() => void)[]) | undefined;
            deactivated?: ((() => void) | (() => void)[]) | undefined;
            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
            destroyed?: ((() => void) | (() => void)[]) | undefined;
            unmounted?: ((() => void) | (() => void)[]) | undefined;
            renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
            renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
            errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void)[]) | undefined;
        };
        $forceUpdate: () => void;
        $nextTick: typeof vue.nextTick;
        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
    } & Readonly<vue.ExtractPropTypes<{
        readonly name: {
            readonly required: false;
            readonly type: vue.PropType<string>;
        };
        readonly form: {
            readonly required: false;
            readonly type: vue.PropType<FormInstance<any>>;
        };
        readonly initialValues: {
            readonly required: false;
            readonly type: vue.PropType<Record<string, any>>;
        };
        readonly enableReinitialize: {
            readonly required: false;
            readonly type: vue.PropType<boolean>;
        };
        readonly rules: {
            readonly required: false;
            readonly type: vue.PropType<Rules>;
        };
        readonly validateTrigger: {
            readonly required: false;
            readonly type: vue.PropType<ValidateTrigger | ValidateTrigger[]>;
        };
        readonly validateMessages: {
            readonly required: false;
            readonly type: vue.PropType<ValidateMessages>;
        };
        readonly classPrefix: {
            readonly required: false;
            readonly type: vue.PropType<string>;
            readonly default: "ez";
        };
        readonly preserveValues: {
            readonly required: false;
            readonly type: vue.PropType<boolean>;
            readonly default: true;
        };
        readonly onSubmit: {
            readonly required: false;
            readonly type: vue.PropType<(values: any) => void>;
        };
        readonly onChange: {
            readonly required: false;
            readonly type: vue.PropType<(values: any) => void>;
        };
        readonly onError: {
            readonly required: false;
            readonly type: vue.PropType<(errors: ValidateError[]) => void>;
        };
        readonly onReset: {
            readonly required: false;
            readonly type: vue.PropType<() => void>;
        };
    }>> & vue.ShallowUnwrapRef<() => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>> & {} & vue.ComponentCustomProperties & {};
    __isFragment?: undefined;
    __isTeleport?: undefined;
    __isSuspense?: undefined;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    readonly name: {
        readonly required: false;
        readonly type: vue.PropType<string>;
    };
    readonly form: {
        readonly required: false;
        readonly type: vue.PropType<FormInstance<any>>;
    };
    readonly initialValues: {
        readonly required: false;
        readonly type: vue.PropType<Record<string, any>>;
    };
    readonly enableReinitialize: {
        readonly required: false;
        readonly type: vue.PropType<boolean>;
    };
    readonly rules: {
        readonly required: false;
        readonly type: vue.PropType<Rules>;
    };
    readonly validateTrigger: {
        readonly required: false;
        readonly type: vue.PropType<ValidateTrigger | ValidateTrigger[]>;
    };
    readonly validateMessages: {
        readonly required: false;
        readonly type: vue.PropType<ValidateMessages>;
    };
    readonly classPrefix: {
        readonly required: false;
        readonly type: vue.PropType<string>;
        readonly default: "ez";
    };
    readonly preserveValues: {
        readonly required: false;
        readonly type: vue.PropType<boolean>;
        readonly default: true;
    };
    readonly onSubmit: {
        readonly required: false;
        readonly type: vue.PropType<(values: any) => void>;
    };
    readonly onChange: {
        readonly required: false;
        readonly type: vue.PropType<(values: any) => void>;
    };
    readonly onError: {
        readonly required: false;
        readonly type: vue.PropType<(errors: ValidateError[]) => void>;
    };
    readonly onReset: {
        readonly required: false;
        readonly type: vue.PropType<() => void>;
    };
}>>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    readonly classPrefix: string;
    readonly preserveValues: boolean;
}, {}, string, {}> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new () => {
    $slots: {
        default: (slotValue: FormSlotProps) => any;
    };
});

declare const EzFormErrors: {
    new (...args: any[]): {
        $: vue.ComponentInternalInstance;
        $data: {};
        $props: {
            readonly name?: NamePath | undefined;
            class?: unknown;
            style?: unknown;
            key?: string | number | symbol | undefined;
            ref?: vue.VNodeRef | undefined;
            ref_for?: boolean | undefined;
            ref_key?: string | undefined;
            onVnodeBeforeMount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
            onVnodeMounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
            onVnodeBeforeUpdate?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
            onVnodeUpdated?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
            onVnodeBeforeUnmount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
            onVnodeUnmounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
        };
        $attrs: {
            [x: string]: unknown;
        };
        $refs: {
            [x: string]: unknown;
        };
        $slots: Readonly<{
            [name: string]: vue.Slot<any> | undefined;
        }>;
        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
        $emit: (event: string, ...args: any[]) => void;
        $el: any;
        $options: vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
            name: {
                type: PropType<NamePath>;
                required: false;
            };
        }>>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>[] | undefined, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {}, {}, string, {}> & {
            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
            created?: ((() => void) | (() => void)[]) | undefined;
            beforeMount?: ((() => void) | (() => void)[]) | undefined;
            mounted?: ((() => void) | (() => void)[]) | undefined;
            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
            updated?: ((() => void) | (() => void)[]) | undefined;
            activated?: ((() => void) | (() => void)[]) | undefined;
            deactivated?: ((() => void) | (() => void)[]) | undefined;
            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
            destroyed?: ((() => void) | (() => void)[]) | undefined;
            unmounted?: ((() => void) | (() => void)[]) | undefined;
            renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
            renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
            errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void)[]) | undefined;
        };
        $forceUpdate: () => void;
        $nextTick: typeof vue.nextTick;
        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
    } & Readonly<vue.ExtractPropTypes<{
        name: {
            type: PropType<NamePath>;
            required: false;
        };
    }>> & vue.ShallowUnwrapRef<() => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>[] | undefined> & {} & vue.ComponentCustomProperties & {};
    __isFragment?: undefined;
    __isTeleport?: undefined;
    __isSuspense?: undefined;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    name: {
        type: PropType<NamePath>;
        required: false;
    };
}>>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>[] | undefined, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {}, {}, string, {}> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new () => {
    $slots: {
        default: (props: {
            errors: ValidateError[];
        }) => void;
    };
});

declare const EzFormItem: {
    new (...args: any[]): {
        $: vue.ComponentInternalInstance;
        $data: {};
        $props: {
            readonly validateTrigger?: ValidateTrigger | ValidateTrigger[] | undefined;
            readonly valuePropName?: string | undefined;
            readonly blurEventPropName?: string | undefined;
            readonly getValueFromChangeEvent?: ((event: any) => any) | undefined;
            readonly valueTransformer?: FormItemValueTransformer<any, any> | undefined;
            readonly autoBinding?: boolean | undefined;
            readonly inputNodeIndex?: number | undefined;
            readonly requiredMark?: string | boolean | undefined;
            readonly name?: NamePath | undefined;
            readonly rules?: Rule | undefined;
            class?: unknown;
            readonly label?: string | undefined;
            readonly formItem?: FormItemInstance | undefined;
            readonly defaultValue?: unknown;
            readonly changeEventPropName?: string | undefined;
            readonly validateFirst?: boolean | undefined;
            readonly noStyle?: boolean | undefined;
            readonly colon?: boolean | undefined;
            style?: unknown;
            key?: string | number | symbol | undefined;
            ref?: vue.VNodeRef | undefined;
            ref_for?: boolean | undefined;
            ref_key?: string | undefined;
            onVnodeBeforeMount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
            onVnodeMounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
            onVnodeBeforeUpdate?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
            onVnodeUpdated?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
            onVnodeBeforeUnmount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
            onVnodeUnmounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
        };
        $attrs: {
            [x: string]: unknown;
        };
        $refs: {
            [x: string]: unknown;
        };
        $slots: Readonly<{
            [name: string]: vue.Slot<any> | undefined;
        }>;
        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
        $emit: (event: string, ...args: any[]) => void;
        $el: any;
        $options: vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
            readonly label: {
                readonly required: false;
                readonly type: vue.PropType<string>;
            };
            readonly name: {
                readonly required: false;
                readonly type: vue.PropType<NamePath>;
            };
            readonly formItem: {
                readonly required: false;
                readonly type: vue.PropType<FormItemInstance>;
            };
            readonly defaultValue: {
                readonly required: false;
            };
            readonly valuePropName: {
                readonly required: false;
                readonly type: vue.PropType<string>;
                readonly default: "value";
            };
            readonly changeEventPropName: {
                readonly required: false;
                readonly type: vue.PropType<string>;
            };
            readonly blurEventPropName: {
                readonly required: false;
                readonly type: vue.PropType<string>;
                readonly default: "blur";
            };
            readonly getValueFromChangeEvent: {
                readonly required: false;
                readonly type: vue.PropType<(event: any) => any>;
                readonly default: (event: any) => any;
            };
            readonly valueTransformer: {
                readonly required: false;
                readonly type: vue.PropType<FormItemValueTransformer<any, any>>;
                readonly default: () => {
                    in: (value: any) => any;
                    out: (value: any) => any;
                };
            };
            readonly autoBinding: {
                readonly required: false;
                readonly type: vue.PropType<boolean>;
                readonly default: true;
            };
            readonly inputNodeIndex: {
                readonly required: false;
                readonly type: vue.PropType<number>;
                readonly default: 0;
            };
            readonly rules: {
                readonly required: false;
                readonly type: vue.PropType<Rule>;
            };
            readonly requiredMark: {
                readonly required: false;
                readonly type: vue.PropType<string | boolean>;
                readonly default: true;
            };
            readonly validateTrigger: {
                readonly required: false;
                readonly type: vue.PropType<ValidateTrigger | ValidateTrigger[]>;
                readonly default: "change";
            };
            readonly validateFirst: {
                readonly required: false;
                readonly type: vue.PropType<boolean>;
            };
            readonly noStyle: {
                readonly required: false;
                readonly type: vue.PropType<boolean>;
            };
            readonly colon: {
                readonly required: false;
                readonly type: vue.PropType<boolean>;
            };
        }>>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
            readonly validateTrigger: ValidateTrigger | ValidateTrigger[];
            readonly valuePropName: string;
            readonly blurEventPropName: string;
            readonly getValueFromChangeEvent: (event: any) => any;
            readonly valueTransformer: FormItemValueTransformer<any, any>;
            readonly autoBinding: boolean;
            readonly inputNodeIndex: number;
            readonly requiredMark: string | boolean;
        }, {}, string, {}> & {
            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
            created?: ((() => void) | (() => void)[]) | undefined;
            beforeMount?: ((() => void) | (() => void)[]) | undefined;
            mounted?: ((() => void) | (() => void)[]) | undefined;
            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
            updated?: ((() => void) | (() => void)[]) | undefined;
            activated?: ((() => void) | (() => void)[]) | undefined;
            deactivated?: ((() => void) | (() => void)[]) | undefined;
            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
            destroyed?: ((() => void) | (() => void)[]) | undefined;
            unmounted?: ((() => void) | (() => void)[]) | undefined;
            renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
            renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
            errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void)[]) | undefined;
        };
        $forceUpdate: () => void;
        $nextTick: typeof vue.nextTick;
        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
    } & Readonly<vue.ExtractPropTypes<{
        readonly label: {
            readonly required: false;
            readonly type: vue.PropType<string>;
        };
        readonly name: {
            readonly required: false;
            readonly type: vue.PropType<NamePath>;
        };
        readonly formItem: {
            readonly required: false;
            readonly type: vue.PropType<FormItemInstance>;
        };
        readonly defaultValue: {
            readonly required: false;
        };
        readonly valuePropName: {
            readonly required: false;
            readonly type: vue.PropType<string>;
            readonly default: "value";
        };
        readonly changeEventPropName: {
            readonly required: false;
            readonly type: vue.PropType<string>;
        };
        readonly blurEventPropName: {
            readonly required: false;
            readonly type: vue.PropType<string>;
            readonly default: "blur";
        };
        readonly getValueFromChangeEvent: {
            readonly required: false;
            readonly type: vue.PropType<(event: any) => any>;
            readonly default: (event: any) => any;
        };
        readonly valueTransformer: {
            readonly required: false;
            readonly type: vue.PropType<FormItemValueTransformer<any, any>>;
            readonly default: () => {
                in: (value: any) => any;
                out: (value: any) => any;
            };
        };
        readonly autoBinding: {
            readonly required: false;
            readonly type: vue.PropType<boolean>;
            readonly default: true;
        };
        readonly inputNodeIndex: {
            readonly required: false;
            readonly type: vue.PropType<number>;
            readonly default: 0;
        };
        readonly rules: {
            readonly required: false;
            readonly type: vue.PropType<Rule>;
        };
        readonly requiredMark: {
            readonly required: false;
            readonly type: vue.PropType<string | boolean>;
            readonly default: true;
        };
        readonly validateTrigger: {
            readonly required: false;
            readonly type: vue.PropType<ValidateTrigger | ValidateTrigger[]>;
            readonly default: "change";
        };
        readonly validateFirst: {
            readonly required: false;
            readonly type: vue.PropType<boolean>;
        };
        readonly noStyle: {
            readonly required: false;
            readonly type: vue.PropType<boolean>;
        };
        readonly colon: {
            readonly required: false;
            readonly type: vue.PropType<boolean>;
        };
    }>> & vue.ShallowUnwrapRef<() => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>> & {} & vue.ComponentCustomProperties & {};
    __isFragment?: undefined;
    __isTeleport?: undefined;
    __isSuspense?: undefined;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    readonly label: {
        readonly required: false;
        readonly type: vue.PropType<string>;
    };
    readonly name: {
        readonly required: false;
        readonly type: vue.PropType<NamePath>;
    };
    readonly formItem: {
        readonly required: false;
        readonly type: vue.PropType<FormItemInstance>;
    };
    readonly defaultValue: {
        readonly required: false;
    };
    readonly valuePropName: {
        readonly required: false;
        readonly type: vue.PropType<string>;
        readonly default: "value";
    };
    readonly changeEventPropName: {
        readonly required: false;
        readonly type: vue.PropType<string>;
    };
    readonly blurEventPropName: {
        readonly required: false;
        readonly type: vue.PropType<string>;
        readonly default: "blur";
    };
    readonly getValueFromChangeEvent: {
        readonly required: false;
        readonly type: vue.PropType<(event: any) => any>;
        readonly default: (event: any) => any;
    };
    readonly valueTransformer: {
        readonly required: false;
        readonly type: vue.PropType<FormItemValueTransformer<any, any>>;
        readonly default: () => {
            in: (value: any) => any;
            out: (value: any) => any;
        };
    };
    readonly autoBinding: {
        readonly required: false;
        readonly type: vue.PropType<boolean>;
        readonly default: true;
    };
    readonly inputNodeIndex: {
        readonly required: false;
        readonly type: vue.PropType<number>;
        readonly default: 0;
    };
    readonly rules: {
        readonly required: false;
        readonly type: vue.PropType<Rule>;
    };
    readonly requiredMark: {
        readonly required: false;
        readonly type: vue.PropType<string | boolean>;
        readonly default: true;
    };
    readonly validateTrigger: {
        readonly required: false;
        readonly type: vue.PropType<ValidateTrigger | ValidateTrigger[]>;
        readonly default: "change";
    };
    readonly validateFirst: {
        readonly required: false;
        readonly type: vue.PropType<boolean>;
    };
    readonly noStyle: {
        readonly required: false;
        readonly type: vue.PropType<boolean>;
    };
    readonly colon: {
        readonly required: false;
        readonly type: vue.PropType<boolean>;
    };
}>>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    readonly validateTrigger: ValidateTrigger | ValidateTrigger[];
    readonly valuePropName: string;
    readonly blurEventPropName: string;
    readonly getValueFromChangeEvent: (event: any) => any;
    readonly valueTransformer: FormItemValueTransformer<any, any>;
    readonly autoBinding: boolean;
    readonly inputNodeIndex: number;
    readonly requiredMark: string | boolean;
}, {}, string, {}> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new () => {
    $slots: {
        default: (props: FormItemSlotProps) => void;
        errors: (props: {
            error: ValidateError;
            form: FormInstance;
            formItem: FormItemInstance;
        }) => void;
        extra: (props: {
            form: FormInstance;
            formItem: FormItemInstance;
        }) => void;
    };
});

declare const EzFormItemAutoBindingInput: {
    new (...args: any[]): {
        $: vue.ComponentInternalInstance;
        $data: {};
        $props: {
            autoBinding?: boolean | undefined;
            class?: unknown;
            readonly valuePropName: string;
            readonly changeEventPropName?: string | undefined;
            readonly blurEventPropName: string;
            readonly inputNodeIndex?: number | undefined;
            style?: unknown;
            key?: string | number | symbol | undefined;
            ref?: vue.VNodeRef | undefined;
            ref_for?: boolean | undefined;
            ref_key?: string | undefined;
            onVnodeBeforeMount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
            onVnodeMounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
            onVnodeBeforeUpdate?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
            onVnodeUpdated?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
            onVnodeBeforeUnmount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
            onVnodeUnmounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
        };
        $attrs: {
            [x: string]: unknown;
        };
        $refs: {
            [x: string]: unknown;
        };
        $slots: Readonly<{
            [name: string]: vue.Slot<any> | undefined;
        }>;
        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
        $emit: (event: string, ...args: any[]) => void;
        $el: any;
        $options: vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
            inputNodeIndex: {
                type: NumberConstructor;
                required: false;
            };
            autoBinding: {
                type: BooleanConstructor;
                required: false;
            };
            changeEventPropName: {
                type: StringConstructor;
                required: false;
            };
            blurEventPropName: {
                type: StringConstructor;
                required: true;
            };
            valuePropName: {
                type: StringConstructor;
                required: true;
            };
        }>>, vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>[] | (() => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>[]) | undefined, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
            autoBinding: boolean;
        }, {}, string, {}> & {
            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
            created?: ((() => void) | (() => void)[]) | undefined;
            beforeMount?: ((() => void) | (() => void)[]) | undefined;
            mounted?: ((() => void) | (() => void)[]) | undefined;
            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
            updated?: ((() => void) | (() => void)[]) | undefined;
            activated?: ((() => void) | (() => void)[]) | undefined;
            deactivated?: ((() => void) | (() => void)[]) | undefined;
            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
            destroyed?: ((() => void) | (() => void)[]) | undefined;
            unmounted?: ((() => void) | (() => void)[]) | undefined;
            renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
            renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
            errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void)[]) | undefined;
        };
        $forceUpdate: () => void;
        $nextTick: typeof vue.nextTick;
        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
    } & Readonly<vue.ExtractPropTypes<{
        inputNodeIndex: {
            type: NumberConstructor;
            required: false;
        };
        autoBinding: {
            type: BooleanConstructor;
            required: false;
        };
        changeEventPropName: {
            type: StringConstructor;
            required: false;
        };
        blurEventPropName: {
            type: StringConstructor;
            required: true;
        };
        valuePropName: {
            type: StringConstructor;
            required: true;
        };
    }>> & vue.ShallowUnwrapRef<{} | vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>[] | (() => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>[])> & {} & vue.ComponentCustomProperties & {};
    __isFragment?: undefined;
    __isTeleport?: undefined;
    __isSuspense?: undefined;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    inputNodeIndex: {
        type: NumberConstructor;
        required: false;
    };
    autoBinding: {
        type: BooleanConstructor;
        required: false;
    };
    changeEventPropName: {
        type: StringConstructor;
        required: false;
    };
    blurEventPropName: {
        type: StringConstructor;
        required: true;
    };
    valuePropName: {
        type: StringConstructor;
        required: true;
    };
}>>, vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>[] | (() => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>[]) | undefined, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    autoBinding: boolean;
}, {}, string, {}> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new () => {
    $slots: {
        default: (props: FormItemSlotProps) => void;
    };
});

declare const EzFormList: {
    new (...args: any[]): {
        $: vue.ComponentInternalInstance;
        $data: {};
        $props: {
            readonly validateTrigger?: ValidateTrigger | ValidateTrigger[] | undefined;
            readonly valuePropName?: string | undefined;
            readonly blurEventPropName?: string | undefined;
            readonly getValueFromChangeEvent?: ((event: any) => any) | undefined;
            readonly valueTransformer?: FormItemValueTransformer<any, any> | undefined;
            readonly autoBinding?: boolean | undefined;
            readonly requiredMark?: string | boolean | undefined;
            readonly name: NamePath;
            readonly rules?: Rule | undefined;
            class?: unknown;
            readonly label?: string | undefined;
            readonly defaultValue?: any[] | undefined;
            readonly changeEventPropName?: string | undefined;
            readonly validateFirst?: boolean | undefined;
            readonly noStyle?: boolean | undefined;
            style?: unknown;
            key?: string | number | symbol | undefined;
            ref?: vue.VNodeRef | undefined;
            ref_for?: boolean | undefined;
            ref_key?: string | undefined;
            onVnodeBeforeMount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
            onVnodeMounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
            onVnodeBeforeUpdate?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
            onVnodeUpdated?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>, oldVNode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
            onVnodeBeforeUnmount?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
            onVnodeUnmounted?: ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void) | ((vnode: vue.VNode<vue.RendererNode, vue.RendererElement, {
                [key: string]: any;
            }>) => void)[] | undefined;
            readonly formList?: FormListInstance | undefined;
        };
        $attrs: {
            [x: string]: unknown;
        };
        $refs: {
            [x: string]: unknown;
        };
        $slots: Readonly<{
            [name: string]: vue.Slot<any> | undefined;
        }>;
        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
        $emit: (event: string, ...args: any[]) => void;
        $el: any;
        $options: vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
            readonly label: {
                readonly required: false;
                readonly type: vue.PropType<string>;
            };
            readonly name: {
                readonly type: vue.PropType<NamePath>;
                readonly required: true;
            };
            readonly formList: {
                readonly required: false;
                readonly type: vue.PropType<FormListInstance>;
            };
            readonly defaultValue: {
                readonly required: false;
                readonly type: vue.PropType<any[]>;
            };
            readonly valuePropName: {
                readonly required: false;
                readonly type: vue.PropType<string>;
                readonly default: "value";
            };
            readonly changeEventPropName: {
                readonly required: false;
                readonly type: vue.PropType<string>;
            };
            readonly blurEventPropName: {
                readonly required: false;
                readonly type: vue.PropType<string>;
                readonly default: "blur";
            };
            readonly getValueFromChangeEvent: {
                readonly required: false;
                readonly type: vue.PropType<(event: any) => any>;
                readonly default: (event: any) => any;
            };
            readonly valueTransformer: {
                readonly required: false;
                readonly type: vue.PropType<FormItemValueTransformer<any, any>>;
                readonly default: () => {
                    in: (value: any) => any;
                    out: (value: any) => any;
                };
            };
            readonly autoBinding: {
                readonly required: false;
                readonly type: vue.PropType<boolean>;
                readonly default: true;
            };
            readonly rules: {
                readonly required: false;
                readonly type: vue.PropType<Rule>;
            };
            readonly requiredMark: {
                readonly required: false;
                readonly type: vue.PropType<string | boolean>;
                readonly default: true;
            };
            readonly validateTrigger: {
                readonly required: false;
                readonly type: vue.PropType<ValidateTrigger | ValidateTrigger[]>;
                readonly default: "change";
            };
            readonly validateFirst: {
                readonly required: false;
                readonly type: vue.PropType<boolean>;
            };
            readonly noStyle: {
                readonly required: false;
                readonly type: vue.PropType<boolean>;
            };
        }>>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
            [key: string]: any;
        }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
            readonly validateTrigger: ValidateTrigger | ValidateTrigger[];
            readonly valuePropName: string;
            readonly blurEventPropName: string;
            readonly getValueFromChangeEvent: (event: any) => any;
            readonly valueTransformer: FormItemValueTransformer<any, any>;
            readonly autoBinding: boolean;
            readonly requiredMark: string | boolean;
        }, {}, string, {}> & {
            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
            created?: ((() => void) | (() => void)[]) | undefined;
            beforeMount?: ((() => void) | (() => void)[]) | undefined;
            mounted?: ((() => void) | (() => void)[]) | undefined;
            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
            updated?: ((() => void) | (() => void)[]) | undefined;
            activated?: ((() => void) | (() => void)[]) | undefined;
            deactivated?: ((() => void) | (() => void)[]) | undefined;
            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
            destroyed?: ((() => void) | (() => void)[]) | undefined;
            unmounted?: ((() => void) | (() => void)[]) | undefined;
            renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
            renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
            errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void)[]) | undefined;
        };
        $forceUpdate: () => void;
        $nextTick: typeof vue.nextTick;
        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
    } & Readonly<vue.ExtractPropTypes<{
        readonly label: {
            readonly required: false;
            readonly type: vue.PropType<string>;
        };
        readonly name: {
            readonly type: vue.PropType<NamePath>;
            readonly required: true;
        };
        readonly formList: {
            readonly required: false;
            readonly type: vue.PropType<FormListInstance>;
        };
        readonly defaultValue: {
            readonly required: false;
            readonly type: vue.PropType<any[]>;
        };
        readonly valuePropName: {
            readonly required: false;
            readonly type: vue.PropType<string>;
            readonly default: "value";
        };
        readonly changeEventPropName: {
            readonly required: false;
            readonly type: vue.PropType<string>;
        };
        readonly blurEventPropName: {
            readonly required: false;
            readonly type: vue.PropType<string>;
            readonly default: "blur";
        };
        readonly getValueFromChangeEvent: {
            readonly required: false;
            readonly type: vue.PropType<(event: any) => any>;
            readonly default: (event: any) => any;
        };
        readonly valueTransformer: {
            readonly required: false;
            readonly type: vue.PropType<FormItemValueTransformer<any, any>>;
            readonly default: () => {
                in: (value: any) => any;
                out: (value: any) => any;
            };
        };
        readonly autoBinding: {
            readonly required: false;
            readonly type: vue.PropType<boolean>;
            readonly default: true;
        };
        readonly rules: {
            readonly required: false;
            readonly type: vue.PropType<Rule>;
        };
        readonly requiredMark: {
            readonly required: false;
            readonly type: vue.PropType<string | boolean>;
            readonly default: true;
        };
        readonly validateTrigger: {
            readonly required: false;
            readonly type: vue.PropType<ValidateTrigger | ValidateTrigger[]>;
            readonly default: "change";
        };
        readonly validateFirst: {
            readonly required: false;
            readonly type: vue.PropType<boolean>;
        };
        readonly noStyle: {
            readonly required: false;
            readonly type: vue.PropType<boolean>;
        };
    }>> & vue.ShallowUnwrapRef<() => vue.VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>> & {} & vue.ComponentCustomProperties & {};
    __isFragment?: undefined;
    __isTeleport?: undefined;
    __isSuspense?: undefined;
} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
    readonly label: {
        readonly required: false;
        readonly type: vue.PropType<string>;
    };
    readonly name: {
        readonly type: vue.PropType<NamePath>;
        readonly required: true;
    };
    readonly formList: {
        readonly required: false;
        readonly type: vue.PropType<FormListInstance>;
    };
    readonly defaultValue: {
        readonly required: false;
        readonly type: vue.PropType<any[]>;
    };
    readonly valuePropName: {
        readonly required: false;
        readonly type: vue.PropType<string>;
        readonly default: "value";
    };
    readonly changeEventPropName: {
        readonly required: false;
        readonly type: vue.PropType<string>;
    };
    readonly blurEventPropName: {
        readonly required: false;
        readonly type: vue.PropType<string>;
        readonly default: "blur";
    };
    readonly getValueFromChangeEvent: {
        readonly required: false;
        readonly type: vue.PropType<(event: any) => any>;
        readonly default: (event: any) => any;
    };
    readonly valueTransformer: {
        readonly required: false;
        readonly type: vue.PropType<FormItemValueTransformer<any, any>>;
        readonly default: () => {
            in: (value: any) => any;
            out: (value: any) => any;
        };
    };
    readonly autoBinding: {
        readonly required: false;
        readonly type: vue.PropType<boolean>;
        readonly default: true;
    };
    readonly rules: {
        readonly required: false;
        readonly type: vue.PropType<Rule>;
    };
    readonly requiredMark: {
        readonly required: false;
        readonly type: vue.PropType<string | boolean>;
        readonly default: true;
    };
    readonly validateTrigger: {
        readonly required: false;
        readonly type: vue.PropType<ValidateTrigger | ValidateTrigger[]>;
        readonly default: "change";
    };
    readonly validateFirst: {
        readonly required: false;
        readonly type: vue.PropType<boolean>;
    };
    readonly noStyle: {
        readonly required: false;
        readonly type: vue.PropType<boolean>;
    };
}>>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
    readonly validateTrigger: ValidateTrigger | ValidateTrigger[];
    readonly valuePropName: string;
    readonly blurEventPropName: string;
    readonly getValueFromChangeEvent: (event: any) => any;
    readonly valueTransformer: FormItemValueTransformer<any, any>;
    readonly autoBinding: boolean;
    readonly requiredMark: string | boolean;
}, {}, string, {}> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new () => {
    $slots: {
        default: (props: FormListSlotProps) => void;
        errors: (props: {
            error: ValidateError;
            form: FormInstance;
            formList: FormListInstance;
        }) => void;
        extra: (props: {
            form: FormInstance;
            formList: FormListInstance;
        }) => void;
    };
});

declare const EzFormDevtool: Plugin;

/**
 *
 * @param props
 * @returns
 */
declare function useForm<Values extends object = Record<PropertyKey, any>>(props?: FormSettings): FormInstance<Values>;

interface UseFormComponentLogicsResult {
    submit: FormInstance["submit"];
    reset: FormInstance["reset"];
    formInstance: FormInstance;
}
declare function useFormComponentLogics(props: FormSettings, emit: FormEmitter): UseFormComponentLogicsResult;

declare function useFormItem(inputProps?: FormItemProps): FormItemInstance;

declare function useFormItemAutoBinding(formItemInstance: FormItemInstance, props: {
    changeEventPropName?: string;
    blurEventPropName: string;
    valuePropName: string;
}): {
    getVNodesFromDefaultSlot: () => VNode<vue.RendererNode, vue.RendererElement, {
        [key: string]: any;
    }>[];
    slotData: vue.ComputedRef<FormItemSlotProps>;
    getInputItemProps: (vNode: VNode) => {
        value: any;
        onInput: (event: any) => void;
        onChange: (event: any) => void;
        onBlur: () => void;
        id: string;
    } | {
        [x: string]: any;
        id: string;
        value?: undefined;
        onInput?: undefined;
        onChange?: undefined;
        onBlur?: undefined;
    };
};

interface UseFormItemComponentLogicsProps extends FormItemProps {
    changeEventPropName?: string;
    blurEventPropName: string;
    valuePropName: string;
}
interface UseFormItemComponentLogicsResult {
    formItemInstance: FormItemInstance;
    formInstance: FormInstance;
}
declare function useFormItemComponentLogics(props: UseFormItemComponentLogicsProps, emit: FormItemEmitter): UseFormItemComponentLogicsResult;

declare function useFormList(inputProps?: FormListProps): FormListInstance;

interface UseFormListComponentLogicsResult {
    formListInstance: FormListInstance;
    formInstance: FormInstance;
}
declare function useFormListComponentLogics(props: FormListProps, emit: FormItemEmitter): UseFormListComponentLogicsResult;

declare function useInjectForm(): FormInstance<any>;

declare function useInjectFormItem(): FormItemInstance;

declare function useInjectFormList(): FormListInstance;

declare function useEzFormPluginOptions(): PluginOptions;

declare const getFormDefinePropsObject: () => {
    readonly name: {
        readonly required: false;
        readonly type: PropType<string>;
    };
    readonly form: {
        readonly required: false;
        readonly type: PropType<FormInstance<any>>;
    };
    readonly initialValues: {
        readonly required: false;
        readonly type: PropType<Record<string, any>>;
    };
    readonly enableReinitialize: {
        readonly required: false;
        readonly type: PropType<boolean>;
    };
    readonly rules: {
        readonly required: false;
        readonly type: PropType<Rules>;
    };
    readonly validateTrigger: {
        readonly required: false;
        readonly type: PropType<ValidateTrigger | ValidateTrigger[]>;
    };
    readonly validateMessages: {
        readonly required: false;
        readonly type: PropType<ValidateMessages>;
    };
    readonly classPrefix: {
        readonly required: false;
        readonly type: PropType<string>;
        readonly default: "ez";
    };
    readonly preserveValues: {
        readonly required: false;
        readonly type: PropType<boolean>;
        readonly default: true;
    };
    readonly onSubmit: {
        readonly required: false;
        readonly type: PropType<(values: any) => void>;
    };
    readonly onChange: {
        readonly required: false;
        readonly type: PropType<(values: any) => void>;
    };
    readonly onError: {
        readonly required: false;
        readonly type: PropType<(errors: ValidateError[]) => void>;
    };
    readonly onReset: {
        readonly required: false;
        readonly type: PropType<() => void>;
    };
};
declare const getFormItemDefinePropsObject: () => {
    readonly label: {
        readonly required: false;
        readonly type: PropType<string>;
    };
    readonly name: {
        readonly required: false;
        readonly type: PropType<NamePath>;
    };
    readonly formItem: {
        readonly required: false;
        readonly type: PropType<FormItemInstance>;
    };
    readonly defaultValue: {
        readonly required: false;
    };
    readonly valuePropName: {
        readonly required: false;
        readonly type: PropType<string>;
        readonly default: "value";
    };
    readonly changeEventPropName: {
        readonly required: false;
        readonly type: PropType<string>;
    };
    readonly blurEventPropName: {
        readonly required: false;
        readonly type: PropType<string>;
        readonly default: "blur";
    };
    readonly getValueFromChangeEvent: {
        readonly required: false;
        readonly type: PropType<(event: any) => any>;
        readonly default: (event: any) => any;
    };
    readonly valueTransformer: {
        readonly required: false;
        readonly type: PropType<FormItemValueTransformer<any, any>>;
        readonly default: () => {
            in: (value: any) => any;
            out: (value: any) => any;
        };
    };
    readonly autoBinding: {
        readonly required: false;
        readonly type: PropType<boolean>;
        readonly default: true;
    };
    readonly inputNodeIndex: {
        readonly required: false;
        readonly type: PropType<number>;
        readonly default: 0;
    };
    readonly rules: {
        readonly required: false;
        readonly type: PropType<Rule>;
    };
    readonly requiredMark: {
        readonly required: false;
        readonly type: PropType<string | boolean>;
        readonly default: true;
    };
    readonly validateTrigger: {
        readonly required: false;
        readonly type: PropType<ValidateTrigger | ValidateTrigger[]>;
        readonly default: "change";
    };
    readonly validateFirst: {
        readonly required: false;
        readonly type: PropType<boolean>;
    };
    readonly noStyle: {
        readonly required: false;
        readonly type: PropType<boolean>;
    };
    readonly colon: {
        readonly required: false;
        readonly type: PropType<boolean>;
    };
};
declare const getFormListDefinePropsObject: () => {
    readonly label: {
        readonly required: false;
        readonly type: PropType<string>;
    };
    readonly name: {
        readonly type: PropType<NamePath>;
        readonly required: true;
    };
    readonly formList: {
        readonly required: false;
        readonly type: PropType<FormListInstance>;
    };
    readonly defaultValue: {
        readonly required: false;
        readonly type: PropType<any[]>;
    };
    readonly valuePropName: {
        readonly required: false;
        readonly type: PropType<string>;
        readonly default: "value";
    };
    readonly changeEventPropName: {
        readonly required: false;
        readonly type: PropType<string>;
    };
    readonly blurEventPropName: {
        readonly required: false;
        readonly type: PropType<string>;
        readonly default: "blur";
    };
    readonly getValueFromChangeEvent: {
        readonly required: false;
        readonly type: PropType<(event: any) => any>;
        readonly default: (event: any) => any;
    };
    readonly valueTransformer: {
        readonly required: false;
        readonly type: PropType<FormItemValueTransformer<any, any>>;
        readonly default: () => {
            in: (value: any) => any;
            out: (value: any) => any;
        };
    };
    readonly autoBinding: {
        readonly required: false;
        readonly type: PropType<boolean>;
        readonly default: true;
    };
    readonly rules: {
        readonly required: false;
        readonly type: PropType<Rule>;
    };
    readonly requiredMark: {
        readonly required: false;
        readonly type: PropType<string | boolean>;
        readonly default: true;
    };
    readonly validateTrigger: {
        readonly required: false;
        readonly type: PropType<ValidateTrigger | ValidateTrigger[]>;
        readonly default: "change";
    };
    readonly validateFirst: {
        readonly required: false;
        readonly type: PropType<boolean>;
    };
    readonly noStyle: {
        readonly required: false;
        readonly type: PropType<boolean>;
    };
};

/**
 * Using form name to get form instance from anywhere in you app.
 * You have to set a name for the form you want to get instance.
 *
 */
declare function getFormInstance<Computed extends boolean | undefined = false>(name: string, isComputed?: Computed | boolean): Computed extends true ? ComputedRef<FormInstance | undefined> : FormInstance | undefined;

/**
 * Using form name and name path to get form item instance from anywhere in you app.
 * You have to set a name for the form you want to get it's form item instance.
 *
 */
declare function getFormItemInstance<Computed extends boolean | undefined = false>(formName: string, namePath: NamePath, isComputed?: Computed | boolean): Computed extends true ? ComputedRef<FormItemInstance | undefined> : FormItemInstance | undefined;

/**
 * Using form name and name path to get form list instance from anywhere in you app.
 * You have to set a name for the form you want to get it's form list instance.
 *
 */
declare function getFormListInstance<Computed extends boolean | undefined = false>(formName: string, namePath: NamePath, isComputed?: Computed | boolean): Computed extends true ? ComputedRef<FormListInstance | undefined> : FormListInstance | undefined;

declare function provideFormInstance(form: FormInstance): void;

declare function provideFormItemInstance(formItemInstance: FormItemInstance): void;

declare function provideFormListInstance(formListInstance: FormListInstance): void;

declare const EzFormPlugin: Plugin;

export { EzForm, EzFormDevtool, EzFormErrors, EzFormItem, EzFormItemAutoBindingInput, EzFormList, FieldMeta, FormEmitter, FormErrorCallback, FormField, FormInstance, FormItemEmitter, FormItemInstance, FormItemProps, FormItemSlotErrorsProps, FormItemSlotExtraProps, FormItemSlotProps, FormItemValueTransformer, FormListInstance, FormListProps, FormListSlotErrorsProps, FormListSlotExtraProps, FormListSlotProps, FormMeta, FormSettings, FormSlotProps, FormSubmitCallback, NamePath, PluginOptions, Rule, RuleItem, Rules, ValidateError, ValidateMessages, ValidateOption, ValidateTrigger, EzFormPlugin as default, getFormDefinePropsObject, getFormInstance, getFormItemDefinePropsObject, getFormItemInstance, getFormListDefinePropsObject, getFormListInstance, provideFormInstance, provideFormItemInstance, provideFormListInstance, useEzFormPluginOptions, useForm, useFormComponentLogics, useFormItem, useFormItemAutoBinding, useFormItemComponentLogics, useFormList, useFormListComponentLogics, useInjectForm, useInjectFormItem, useInjectFormList };