import type { FieldContext } from 'vee-validate';
import type { VNode } from 'vue';
import type { Status } from './props';
type FieldReturnSlotFn<T = object> = (args: FieldContext<any> & T) => VNode[];
type GetSlots<T> = T extends {
    new (): {
        $slots: Record<string, unknown>;
    };
} ? InstanceType<T>['$slots'] : object;
declare const _default: {
    new (...args: any[]): {
        $: import("vue").ComponentInternalInstance;
        $data: {};
        $props: Partial<{
            label: string;
            type: "horizontal" | "vertical";
            modelValue: import("./props").ItemBaseType | import("./props").ItemBaseType[];
            error: string;
            tag: import("@dao-style/core").TagType;
            required: boolean;
            controlProps: Record<string, unknown>;
            modelModifiers: Record<string, boolean>;
            yupConcat: import("yup").BaseSchema<any, import("yup/lib/types").AnyObject, any>;
            yupType: import("yup").BaseSchema<any, import("yup/lib/types").AnyObject, any>;
            validationRules: import("vee-validate").RuleExpression<unknown> | import("vue").Ref<import("vee-validate").RuleExpression<unknown>>;
            validationOptions: Partial<import("vee-validate").FieldOptions<unknown>> | undefined;
            componentValidate: boolean;
            custom: boolean;
            wrapperType: "footer" | "switch" | "text" | "checkbox" | "radio" | undefined;
            paddingTop: string | number;
            paddingBottom: string | number;
            labelWidth: string;
            iconMessage: string;
            helper: string;
        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
            modelValue: {
                type: import("vue").PropType<import("./props").ItemBaseType | import("./props").ItemBaseType[]>;
                default: undefined;
            };
            name: {
                type: import("vue").PropType<string>;
            };
            tag: {
                type: import("vue").PropType<import("@dao-style/core").TagType>;
                default: {
                    new (...args: any[]): {
                        $: import("vue").ComponentInternalInstance;
                        $data: {};
                        $props: Partial<{
                            type: import("@dao-style/core").InputType;
                            modelValue: import("@dao-style/core").ModalValueType;
                            disabled: boolean;
                            status: import("@dao-style/core").InputStatus;
                            size: import("@dao-style/core").InputSize;
                            block: boolean;
                            borderless: boolean;
                            append: string;
                            prepend: string;
                        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
                            modelValue: {
                                type: import("vue").PropType<import("@dao-style/core").ModalValueType>;
                                default: string;
                            };
                            type: {
                                type: import("vue").PropType<import("@dao-style/core").InputType>;
                                default: string;
                                validator: (value: import("@dao-style/core").InputType) => boolean;
                            };
                            disabled: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            size: {
                                type: import("vue").PropType<import("@dao-style/core").InputSize>;
                                default: string;
                                validator: (value: import("@dao-style/core").InputSize) => boolean;
                            };
                            block: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            status: {
                                type: import("vue").PropType<import("@dao-style/core").InputStatus>;
                                default: string;
                                validator: (value: import("@dao-style/core").InputStatus) => boolean;
                            };
                            borderless: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            append: {
                                type: StringConstructor;
                                default: string;
                            };
                            prepend: {
                                type: StringConstructor;
                                default: string;
                            };
                            rootAttrs: {
                                type: ObjectConstructor;
                            };
                        }>> & {
                            onFocus?: ((...args: any[]) => any) | undefined;
                            onBlur?: ((...args: any[]) => any) | undefined;
                            onChange?: ((...args: any[]) => any) | undefined;
                            onInput?: ((...args: any[]) => any) | undefined;
                            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                            "onAfter-reset"?: ((...args: any[]) => any) | undefined;
                        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "size" | "type" | "disabled" | "modelValue" | "block" | "status" | "borderless" | "append" | "prepend">;
                        $attrs: {
                            [x: string]: unknown;
                        };
                        $refs: {
                            [x: string]: unknown;
                        };
                        $slots: Readonly<{
                            [name: string]: import("vue").Slot | undefined;
                        }>;
                        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
                        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
                        $emit: (event: "input" | "change" | "focus" | "blur" | "update:modelValue" | "after-reset", ...args: any[]) => void;
                        $el: any;
                        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                            modelValue: {
                                type: import("vue").PropType<import("@dao-style/core").ModalValueType>;
                                default: string;
                            };
                            type: {
                                type: import("vue").PropType<import("@dao-style/core").InputType>;
                                default: string;
                                validator: (value: import("@dao-style/core").InputType) => boolean;
                            };
                            disabled: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            size: {
                                type: import("vue").PropType<import("@dao-style/core").InputSize>;
                                default: string;
                                validator: (value: import("@dao-style/core").InputSize) => boolean;
                            };
                            block: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            status: {
                                type: import("vue").PropType<import("@dao-style/core").InputStatus>;
                                default: string;
                                validator: (value: import("@dao-style/core").InputStatus) => boolean;
                            };
                            borderless: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            append: {
                                type: StringConstructor;
                                default: string;
                            };
                            prepend: {
                                type: StringConstructor;
                                default: string;
                            };
                            rootAttrs: {
                                type: ObjectConstructor;
                            };
                        }>> & {
                            onFocus?: ((...args: any[]) => any) | undefined;
                            onBlur?: ((...args: any[]) => any) | undefined;
                            onChange?: ((...args: any[]) => any) | undefined;
                            onInput?: ((...args: any[]) => any) | undefined;
                            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                            "onAfter-reset"?: ((...args: any[]) => any) | undefined;
                        }, {
                            currentValue: import("vue").Ref<import("@dao-style/core").ModalValueType>;
                            displayValue: import("vue").ComputedRef<import("@dao-style/core").ModalValueType>;
                            isFocus: import("vue").Ref<boolean>;
                            input: import("vue").Ref<HTMLInputElement | null>;
                            clearable: import("vue").ComputedRef<boolean | "" | 0 | undefined>;
                            wrapClasses: import("vue").ComputedRef<(string | {
                                [x: string]: boolean | "" | 0 | undefined;
                            })[]>;
                            inputClasses: import("vue").ComputedRef<(string | {
                                [x: string]: boolean | import("vue").Slot | undefined;
                            })[]>;
                            inputAttrs: import("vue").ComputedRef<{
                                onInput(event: Event): void;
                                onChange(event: Event): void;
                                onBlur(event: FocusEvent): void;
                                onFocus(event: FocusEvent): void;
                            }>;
                            slots: Readonly<{
                                [name: string]: import("vue").Slot | undefined;
                            }>;
                            resetCurrentVal: () => void;
                            statusClasses: import("vue").ComputedRef<string>;
                            changeNumberValue: (changeType: "increase" | "decrease") => void;
                            isIncreaseDisabled: import("vue").Ref<boolean>;
                            isDecreaseDisabled: import("vue").Ref<boolean>;
                            isChangingNumber: import("vue").Ref<boolean>;
                            inputType: import("vue").ComputedRef<import("@dao-style/core").InputType>;
                            passwordIcon: import("vue").ComputedRef<"icon-eye-slash" | "icon-eye">;
                            toggleShowPassword: () => void;
                        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("input" | "change" | "focus" | "blur" | "update:modelValue" | "after-reset")[], string, {
                            type: import("@dao-style/core").InputType;
                            modelValue: import("@dao-style/core").ModalValueType;
                            disabled: boolean;
                            status: import("@dao-style/core").InputStatus;
                            size: import("@dao-style/core").InputSize;
                            block: boolean;
                            borderless: boolean;
                            append: string;
                            prepend: 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: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[] | undefined;
                            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[] | undefined;
                            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[] | undefined;
                        };
                        $forceUpdate: () => void;
                        $nextTick: typeof import("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?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
                    } & Readonly<import("vue").ExtractPropTypes<{
                        modelValue: {
                            type: import("vue").PropType<import("@dao-style/core").ModalValueType>;
                            default: string;
                        };
                        type: {
                            type: import("vue").PropType<import("@dao-style/core").InputType>;
                            default: string;
                            validator: (value: import("@dao-style/core").InputType) => boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        size: {
                            type: import("vue").PropType<import("@dao-style/core").InputSize>;
                            default: string;
                            validator: (value: import("@dao-style/core").InputSize) => boolean;
                        };
                        block: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        status: {
                            type: import("vue").PropType<import("@dao-style/core").InputStatus>;
                            default: string;
                            validator: (value: import("@dao-style/core").InputStatus) => boolean;
                        };
                        borderless: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        append: {
                            type: StringConstructor;
                            default: string;
                        };
                        prepend: {
                            type: StringConstructor;
                            default: string;
                        };
                        rootAttrs: {
                            type: ObjectConstructor;
                        };
                    }>> & {
                        onFocus?: ((...args: any[]) => any) | undefined;
                        onBlur?: ((...args: any[]) => any) | undefined;
                        onChange?: ((...args: any[]) => any) | undefined;
                        onInput?: ((...args: any[]) => any) | undefined;
                        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                        "onAfter-reset"?: ((...args: any[]) => any) | undefined;
                    } & import("vue").ShallowUnwrapRef<{
                        currentValue: import("vue").Ref<import("@dao-style/core").ModalValueType>;
                        displayValue: import("vue").ComputedRef<import("@dao-style/core").ModalValueType>;
                        isFocus: import("vue").Ref<boolean>;
                        input: import("vue").Ref<HTMLInputElement | null>;
                        clearable: import("vue").ComputedRef<boolean | "" | 0 | undefined>;
                        wrapClasses: import("vue").ComputedRef<(string | {
                            [x: string]: boolean | "" | 0 | undefined;
                        })[]>;
                        inputClasses: import("vue").ComputedRef<(string | {
                            [x: string]: boolean | import("vue").Slot | undefined;
                        })[]>;
                        inputAttrs: import("vue").ComputedRef<{
                            onInput(event: Event): void;
                            onChange(event: Event): void;
                            onBlur(event: FocusEvent): void;
                            onFocus(event: FocusEvent): void;
                        }>;
                        slots: Readonly<{
                            [name: string]: import("vue").Slot | undefined;
                        }>;
                        resetCurrentVal: () => void;
                        statusClasses: import("vue").ComputedRef<string>;
                        changeNumberValue: (changeType: "increase" | "decrease") => void;
                        isIncreaseDisabled: import("vue").Ref<boolean>;
                        isDecreaseDisabled: import("vue").Ref<boolean>;
                        isChangingNumber: import("vue").Ref<boolean>;
                        inputType: import("vue").ComputedRef<import("@dao-style/core").InputType>;
                        passwordIcon: import("vue").ComputedRef<"icon-eye-slash" | "icon-eye">;
                        toggleShowPassword: () => void;
                    }> & import("vue").ComponentCustomProperties;
                    __isFragment?: undefined;
                    __isTeleport?: undefined;
                    __isSuspense?: undefined;
                } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                    modelValue: {
                        type: import("vue").PropType<import("@dao-style/core").ModalValueType>;
                        default: string;
                    };
                    type: {
                        type: import("vue").PropType<import("@dao-style/core").InputType>;
                        default: string;
                        validator: (value: import("@dao-style/core").InputType) => boolean;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: import("vue").PropType<import("@dao-style/core").InputSize>;
                        default: string;
                        validator: (value: import("@dao-style/core").InputSize) => boolean;
                    };
                    block: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    status: {
                        type: import("vue").PropType<import("@dao-style/core").InputStatus>;
                        default: string;
                        validator: (value: import("@dao-style/core").InputStatus) => boolean;
                    };
                    borderless: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    append: {
                        type: StringConstructor;
                        default: string;
                    };
                    prepend: {
                        type: StringConstructor;
                        default: string;
                    };
                    rootAttrs: {
                        type: ObjectConstructor;
                    };
                }>> & {
                    onFocus?: ((...args: any[]) => any) | undefined;
                    onBlur?: ((...args: any[]) => any) | undefined;
                    onChange?: ((...args: any[]) => any) | undefined;
                    onInput?: ((...args: any[]) => any) | undefined;
                    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                    "onAfter-reset"?: ((...args: any[]) => any) | undefined;
                }, {
                    currentValue: import("vue").Ref<import("@dao-style/core").ModalValueType>;
                    displayValue: import("vue").ComputedRef<import("@dao-style/core").ModalValueType>;
                    isFocus: import("vue").Ref<boolean>;
                    input: import("vue").Ref<HTMLInputElement | null>;
                    clearable: import("vue").ComputedRef<boolean | "" | 0 | undefined>;
                    wrapClasses: import("vue").ComputedRef<(string | {
                        [x: string]: boolean | "" | 0 | undefined;
                    })[]>;
                    inputClasses: import("vue").ComputedRef<(string | {
                        [x: string]: boolean | import("vue").Slot | undefined;
                    })[]>;
                    inputAttrs: import("vue").ComputedRef<{
                        onInput(event: Event): void;
                        onChange(event: Event): void;
                        onBlur(event: FocusEvent): void;
                        onFocus(event: FocusEvent): void;
                    }>;
                    slots: Readonly<{
                        [name: string]: import("vue").Slot | undefined;
                    }>;
                    resetCurrentVal: () => void;
                    statusClasses: import("vue").ComputedRef<string>;
                    changeNumberValue: (changeType: "increase" | "decrease") => void;
                    isIncreaseDisabled: import("vue").Ref<boolean>;
                    isDecreaseDisabled: import("vue").Ref<boolean>;
                    isChangingNumber: import("vue").Ref<boolean>;
                    inputType: import("vue").ComputedRef<import("@dao-style/core").InputType>;
                    passwordIcon: import("vue").ComputedRef<"icon-eye-slash" | "icon-eye">;
                    toggleShowPassword: () => void;
                }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("input" | "change" | "focus" | "blur" | "update:modelValue" | "after-reset")[], "input" | "change" | "focus" | "blur" | "update:modelValue" | "after-reset", {
                    type: import("@dao-style/core").InputType;
                    modelValue: import("@dao-style/core").ModalValueType;
                    disabled: boolean;
                    status: import("@dao-style/core").InputStatus;
                    size: import("@dao-style/core").InputSize;
                    block: boolean;
                    borderless: boolean;
                    append: string;
                    prepend: string;
                }, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
                    $props: Partial<import("@dao-style/core").InputProps>;
                    $slots: {
                        prefix: import("@dao-style/core").SlotFn;
                        suffix: import("@dao-style/core").SlotFn;
                        prepend: import("@dao-style/core").SlotFn;
                        append: import("@dao-style/core").SlotFn;
                    };
                });
            };
            controlProps: {
                type: import("vue").PropType<Record<string, unknown>>;
                default: undefined;
            };
            modelModifiers: {
                type: import("vue").PropType<Record<string, boolean>>;
                default: undefined;
            };
            yupConcat: {
                type: import("vue").PropType<import("yup").BaseSchema<any, import("yup/lib/types").AnyObject, any>>;
                default: undefined;
            };
            yupType: {
                type: import("vue").PropType<import("yup").BaseSchema<any, import("yup/lib/types").AnyObject, any>>;
                default: undefined;
            };
            validationRules: {
                type: import("vue").PropType<import("vee-validate").RuleExpression<unknown> | import("vue").Ref<import("vee-validate").RuleExpression<unknown>>>;
                default: undefined;
            };
            validationOptions: {
                type: import("vue").PropType<Partial<import("vee-validate").FieldOptions<unknown>> | undefined>;
                default: undefined;
            };
            componentValidate: {
                type: BooleanConstructor;
                default: boolean;
            };
            custom: {
                type: BooleanConstructor;
                default: boolean;
            };
            label: {
                type: import("vue").PropType<string>;
                default: string;
            };
            required: {
                type: import("vue").PropType<boolean>;
                default: boolean;
            };
            wrapperType: {
                type: import("vue").PropType<"footer" | "switch" | "text" | "checkbox" | "radio" | undefined>;
                default: undefined;
            };
            paddingTop: {
                type: import("vue").PropType<string | number>;
                default: number;
            };
            paddingBottom: {
                type: import("vue").PropType<string | number>;
                default: number;
            };
            labelWidth: {
                type: import("vue").PropType<string>;
                default: string;
            };
            iconMessage: {
                type: import("vue").PropType<string>;
                default: string;
            };
            helper: {
                type: import("vue").PropType<string>;
                default: undefined;
            };
            error: {
                type: import("vue").PropType<string>;
                default: undefined;
            };
            type: {
                type: import("vue").PropType<"horizontal" | "vertical">;
                default: undefined;
            };
        }>> & {
            "onUpdate:modelValue"?: ((value: unknown) => any) | undefined;
            onChange?: ((value: unknown) => any) | undefined;
        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "label" | "type" | "modelValue" | "error" | "tag" | "required" | "controlProps" | "modelModifiers" | "yupConcat" | "yupType" | "validationRules" | "validationOptions" | "componentValidate" | "custom" | "wrapperType" | "paddingTop" | "paddingBottom" | "labelWidth" | "iconMessage" | "helper">;
        $attrs: {
            [x: string]: unknown;
        };
        $refs: {
            [x: string]: unknown;
        };
        $slots: Readonly<{
            [name: string]: import("vue").Slot | undefined;
        }>;
        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
        $emit: ((event: "change", value: unknown) => void) & ((event: "update:modelValue", value: unknown) => void);
        $el: any;
        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
            modelValue: {
                type: import("vue").PropType<import("./props").ItemBaseType | import("./props").ItemBaseType[]>;
                default: undefined;
            };
            name: {
                type: import("vue").PropType<string>;
            };
            tag: {
                type: import("vue").PropType<import("@dao-style/core").TagType>;
                default: {
                    new (...args: any[]): {
                        $: import("vue").ComponentInternalInstance;
                        $data: {};
                        $props: Partial<{
                            type: import("@dao-style/core").InputType;
                            modelValue: import("@dao-style/core").ModalValueType;
                            disabled: boolean;
                            status: import("@dao-style/core").InputStatus;
                            size: import("@dao-style/core").InputSize;
                            block: boolean;
                            borderless: boolean;
                            append: string;
                            prepend: string;
                        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
                            modelValue: {
                                type: import("vue").PropType<import("@dao-style/core").ModalValueType>;
                                default: string;
                            };
                            type: {
                                type: import("vue").PropType<import("@dao-style/core").InputType>;
                                default: string;
                                validator: (value: import("@dao-style/core").InputType) => boolean;
                            };
                            disabled: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            size: {
                                type: import("vue").PropType<import("@dao-style/core").InputSize>;
                                default: string;
                                validator: (value: import("@dao-style/core").InputSize) => boolean;
                            };
                            block: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            status: {
                                type: import("vue").PropType<import("@dao-style/core").InputStatus>;
                                default: string;
                                validator: (value: import("@dao-style/core").InputStatus) => boolean;
                            };
                            borderless: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            append: {
                                type: StringConstructor;
                                default: string;
                            };
                            prepend: {
                                type: StringConstructor;
                                default: string;
                            };
                            rootAttrs: {
                                type: ObjectConstructor;
                            };
                        }>> & {
                            onFocus?: ((...args: any[]) => any) | undefined;
                            onBlur?: ((...args: any[]) => any) | undefined;
                            onChange?: ((...args: any[]) => any) | undefined;
                            onInput?: ((...args: any[]) => any) | undefined;
                            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                            "onAfter-reset"?: ((...args: any[]) => any) | undefined;
                        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "size" | "type" | "disabled" | "modelValue" | "block" | "status" | "borderless" | "append" | "prepend">;
                        $attrs: {
                            [x: string]: unknown;
                        };
                        $refs: {
                            [x: string]: unknown;
                        };
                        $slots: Readonly<{
                            [name: string]: import("vue").Slot | undefined;
                        }>;
                        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
                        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
                        $emit: (event: "input" | "change" | "focus" | "blur" | "update:modelValue" | "after-reset", ...args: any[]) => void;
                        $el: any;
                        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                            modelValue: {
                                type: import("vue").PropType<import("@dao-style/core").ModalValueType>;
                                default: string;
                            };
                            type: {
                                type: import("vue").PropType<import("@dao-style/core").InputType>;
                                default: string;
                                validator: (value: import("@dao-style/core").InputType) => boolean;
                            };
                            disabled: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            size: {
                                type: import("vue").PropType<import("@dao-style/core").InputSize>;
                                default: string;
                                validator: (value: import("@dao-style/core").InputSize) => boolean;
                            };
                            block: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            status: {
                                type: import("vue").PropType<import("@dao-style/core").InputStatus>;
                                default: string;
                                validator: (value: import("@dao-style/core").InputStatus) => boolean;
                            };
                            borderless: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            append: {
                                type: StringConstructor;
                                default: string;
                            };
                            prepend: {
                                type: StringConstructor;
                                default: string;
                            };
                            rootAttrs: {
                                type: ObjectConstructor;
                            };
                        }>> & {
                            onFocus?: ((...args: any[]) => any) | undefined;
                            onBlur?: ((...args: any[]) => any) | undefined;
                            onChange?: ((...args: any[]) => any) | undefined;
                            onInput?: ((...args: any[]) => any) | undefined;
                            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                            "onAfter-reset"?: ((...args: any[]) => any) | undefined;
                        }, {
                            currentValue: import("vue").Ref<import("@dao-style/core").ModalValueType>;
                            displayValue: import("vue").ComputedRef<import("@dao-style/core").ModalValueType>;
                            isFocus: import("vue").Ref<boolean>;
                            input: import("vue").Ref<HTMLInputElement | null>;
                            clearable: import("vue").ComputedRef<boolean | "" | 0 | undefined>;
                            wrapClasses: import("vue").ComputedRef<(string | {
                                [x: string]: boolean | "" | 0 | undefined;
                            })[]>;
                            inputClasses: import("vue").ComputedRef<(string | {
                                [x: string]: boolean | import("vue").Slot | undefined;
                            })[]>;
                            inputAttrs: import("vue").ComputedRef<{
                                onInput(event: Event): void;
                                onChange(event: Event): void;
                                onBlur(event: FocusEvent): void;
                                onFocus(event: FocusEvent): void;
                            }>;
                            slots: Readonly<{
                                [name: string]: import("vue").Slot | undefined;
                            }>;
                            resetCurrentVal: () => void;
                            statusClasses: import("vue").ComputedRef<string>;
                            changeNumberValue: (changeType: "increase" | "decrease") => void;
                            isIncreaseDisabled: import("vue").Ref<boolean>;
                            isDecreaseDisabled: import("vue").Ref<boolean>;
                            isChangingNumber: import("vue").Ref<boolean>;
                            inputType: import("vue").ComputedRef<import("@dao-style/core").InputType>;
                            passwordIcon: import("vue").ComputedRef<"icon-eye-slash" | "icon-eye">;
                            toggleShowPassword: () => void;
                        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("input" | "change" | "focus" | "blur" | "update:modelValue" | "after-reset")[], string, {
                            type: import("@dao-style/core").InputType;
                            modelValue: import("@dao-style/core").ModalValueType;
                            disabled: boolean;
                            status: import("@dao-style/core").InputStatus;
                            size: import("@dao-style/core").InputSize;
                            block: boolean;
                            borderless: boolean;
                            append: string;
                            prepend: 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: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[] | undefined;
                            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[] | undefined;
                            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[] | undefined;
                        };
                        $forceUpdate: () => void;
                        $nextTick: typeof import("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?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
                    } & Readonly<import("vue").ExtractPropTypes<{
                        modelValue: {
                            type: import("vue").PropType<import("@dao-style/core").ModalValueType>;
                            default: string;
                        };
                        type: {
                            type: import("vue").PropType<import("@dao-style/core").InputType>;
                            default: string;
                            validator: (value: import("@dao-style/core").InputType) => boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        size: {
                            type: import("vue").PropType<import("@dao-style/core").InputSize>;
                            default: string;
                            validator: (value: import("@dao-style/core").InputSize) => boolean;
                        };
                        block: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        status: {
                            type: import("vue").PropType<import("@dao-style/core").InputStatus>;
                            default: string;
                            validator: (value: import("@dao-style/core").InputStatus) => boolean;
                        };
                        borderless: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        append: {
                            type: StringConstructor;
                            default: string;
                        };
                        prepend: {
                            type: StringConstructor;
                            default: string;
                        };
                        rootAttrs: {
                            type: ObjectConstructor;
                        };
                    }>> & {
                        onFocus?: ((...args: any[]) => any) | undefined;
                        onBlur?: ((...args: any[]) => any) | undefined;
                        onChange?: ((...args: any[]) => any) | undefined;
                        onInput?: ((...args: any[]) => any) | undefined;
                        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                        "onAfter-reset"?: ((...args: any[]) => any) | undefined;
                    } & import("vue").ShallowUnwrapRef<{
                        currentValue: import("vue").Ref<import("@dao-style/core").ModalValueType>;
                        displayValue: import("vue").ComputedRef<import("@dao-style/core").ModalValueType>;
                        isFocus: import("vue").Ref<boolean>;
                        input: import("vue").Ref<HTMLInputElement | null>;
                        clearable: import("vue").ComputedRef<boolean | "" | 0 | undefined>;
                        wrapClasses: import("vue").ComputedRef<(string | {
                            [x: string]: boolean | "" | 0 | undefined;
                        })[]>;
                        inputClasses: import("vue").ComputedRef<(string | {
                            [x: string]: boolean | import("vue").Slot | undefined;
                        })[]>;
                        inputAttrs: import("vue").ComputedRef<{
                            onInput(event: Event): void;
                            onChange(event: Event): void;
                            onBlur(event: FocusEvent): void;
                            onFocus(event: FocusEvent): void;
                        }>;
                        slots: Readonly<{
                            [name: string]: import("vue").Slot | undefined;
                        }>;
                        resetCurrentVal: () => void;
                        statusClasses: import("vue").ComputedRef<string>;
                        changeNumberValue: (changeType: "increase" | "decrease") => void;
                        isIncreaseDisabled: import("vue").Ref<boolean>;
                        isDecreaseDisabled: import("vue").Ref<boolean>;
                        isChangingNumber: import("vue").Ref<boolean>;
                        inputType: import("vue").ComputedRef<import("@dao-style/core").InputType>;
                        passwordIcon: import("vue").ComputedRef<"icon-eye-slash" | "icon-eye">;
                        toggleShowPassword: () => void;
                    }> & import("vue").ComponentCustomProperties;
                    __isFragment?: undefined;
                    __isTeleport?: undefined;
                    __isSuspense?: undefined;
                } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                    modelValue: {
                        type: import("vue").PropType<import("@dao-style/core").ModalValueType>;
                        default: string;
                    };
                    type: {
                        type: import("vue").PropType<import("@dao-style/core").InputType>;
                        default: string;
                        validator: (value: import("@dao-style/core").InputType) => boolean;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: import("vue").PropType<import("@dao-style/core").InputSize>;
                        default: string;
                        validator: (value: import("@dao-style/core").InputSize) => boolean;
                    };
                    block: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    status: {
                        type: import("vue").PropType<import("@dao-style/core").InputStatus>;
                        default: string;
                        validator: (value: import("@dao-style/core").InputStatus) => boolean;
                    };
                    borderless: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    append: {
                        type: StringConstructor;
                        default: string;
                    };
                    prepend: {
                        type: StringConstructor;
                        default: string;
                    };
                    rootAttrs: {
                        type: ObjectConstructor;
                    };
                }>> & {
                    onFocus?: ((...args: any[]) => any) | undefined;
                    onBlur?: ((...args: any[]) => any) | undefined;
                    onChange?: ((...args: any[]) => any) | undefined;
                    onInput?: ((...args: any[]) => any) | undefined;
                    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                    "onAfter-reset"?: ((...args: any[]) => any) | undefined;
                }, {
                    currentValue: import("vue").Ref<import("@dao-style/core").ModalValueType>;
                    displayValue: import("vue").ComputedRef<import("@dao-style/core").ModalValueType>;
                    isFocus: import("vue").Ref<boolean>;
                    input: import("vue").Ref<HTMLInputElement | null>;
                    clearable: import("vue").ComputedRef<boolean | "" | 0 | undefined>;
                    wrapClasses: import("vue").ComputedRef<(string | {
                        [x: string]: boolean | "" | 0 | undefined;
                    })[]>;
                    inputClasses: import("vue").ComputedRef<(string | {
                        [x: string]: boolean | import("vue").Slot | undefined;
                    })[]>;
                    inputAttrs: import("vue").ComputedRef<{
                        onInput(event: Event): void;
                        onChange(event: Event): void;
                        onBlur(event: FocusEvent): void;
                        onFocus(event: FocusEvent): void;
                    }>;
                    slots: Readonly<{
                        [name: string]: import("vue").Slot | undefined;
                    }>;
                    resetCurrentVal: () => void;
                    statusClasses: import("vue").ComputedRef<string>;
                    changeNumberValue: (changeType: "increase" | "decrease") => void;
                    isIncreaseDisabled: import("vue").Ref<boolean>;
                    isDecreaseDisabled: import("vue").Ref<boolean>;
                    isChangingNumber: import("vue").Ref<boolean>;
                    inputType: import("vue").ComputedRef<import("@dao-style/core").InputType>;
                    passwordIcon: import("vue").ComputedRef<"icon-eye-slash" | "icon-eye">;
                    toggleShowPassword: () => void;
                }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("input" | "change" | "focus" | "blur" | "update:modelValue" | "after-reset")[], "input" | "change" | "focus" | "blur" | "update:modelValue" | "after-reset", {
                    type: import("@dao-style/core").InputType;
                    modelValue: import("@dao-style/core").ModalValueType;
                    disabled: boolean;
                    status: import("@dao-style/core").InputStatus;
                    size: import("@dao-style/core").InputSize;
                    block: boolean;
                    borderless: boolean;
                    append: string;
                    prepend: string;
                }, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
                    $props: Partial<import("@dao-style/core").InputProps>;
                    $slots: {
                        prefix: import("@dao-style/core").SlotFn;
                        suffix: import("@dao-style/core").SlotFn;
                        prepend: import("@dao-style/core").SlotFn;
                        append: import("@dao-style/core").SlotFn;
                    };
                });
            };
            controlProps: {
                type: import("vue").PropType<Record<string, unknown>>;
                default: undefined;
            };
            modelModifiers: {
                type: import("vue").PropType<Record<string, boolean>>;
                default: undefined;
            };
            yupConcat: {
                type: import("vue").PropType<import("yup").BaseSchema<any, import("yup/lib/types").AnyObject, any>>;
                default: undefined;
            };
            yupType: {
                type: import("vue").PropType<import("yup").BaseSchema<any, import("yup/lib/types").AnyObject, any>>;
                default: undefined;
            };
            validationRules: {
                type: import("vue").PropType<import("vee-validate").RuleExpression<unknown> | import("vue").Ref<import("vee-validate").RuleExpression<unknown>>>;
                default: undefined;
            };
            validationOptions: {
                type: import("vue").PropType<Partial<import("vee-validate").FieldOptions<unknown>> | undefined>;
                default: undefined;
            };
            componentValidate: {
                type: BooleanConstructor;
                default: boolean;
            };
            custom: {
                type: BooleanConstructor;
                default: boolean;
            };
            label: {
                type: import("vue").PropType<string>;
                default: string;
            };
            required: {
                type: import("vue").PropType<boolean>;
                default: boolean;
            };
            wrapperType: {
                type: import("vue").PropType<"footer" | "switch" | "text" | "checkbox" | "radio" | undefined>;
                default: undefined;
            };
            paddingTop: {
                type: import("vue").PropType<string | number>;
                default: number;
            };
            paddingBottom: {
                type: import("vue").PropType<string | number>;
                default: number;
            };
            labelWidth: {
                type: import("vue").PropType<string>;
                default: string;
            };
            iconMessage: {
                type: import("vue").PropType<string>;
                default: string;
            };
            helper: {
                type: import("vue").PropType<string>;
                default: undefined;
            };
            error: {
                type: import("vue").PropType<string>;
                default: undefined;
            };
            type: {
                type: import("vue").PropType<"horizontal" | "vertical">;
                default: undefined;
            };
        }>> & {
            "onUpdate:modelValue"?: ((value: unknown) => any) | undefined;
            onChange?: ((value: unknown) => any) | undefined;
        }, {
            currentControlProps: import("vue").ComputedRef<{
                modelModifiers: Record<string, boolean> | undefined;
            }>;
            currentRules: import("vue").ComputedRef<string | Record<string, unknown> | import("yup").BaseSchema<any, import("yup/lib/types").AnyObject, any> | import("vee-validate").GenericValidateFunction<unknown> | import("vee-validate").GenericValidateFunction<unknown>[] | import("vue").Ref<import("vee-validate").RuleExpression<unknown>> | import("yup").NumberSchema<number | undefined, import("yup/lib/types").AnyObject, number | undefined> | import("yup").StringSchema<string | undefined, import("yup/lib/types").AnyObject, string | undefined>>;
            fieldReturn: FieldContext<any>;
            currentValue: import("vue").Ref<any>;
            hasErrorMessage: import("vue").ComputedRef<boolean>;
            status: import("vue").ComputedRef<"default" | "error">;
            controlSlots: import("vue").ComputedRef<import("lodash").Omit<Readonly<{
                [name: string]: import("vue").Slot | undefined;
            }>, string>>;
            formItemPropsObject: import("vue").ComputedRef<{
                [k: string]: string | number | boolean | undefined;
            }>;
        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
            'update:modelValue': (value: unknown) => void;
            change: (value: unknown) => void;
        }, string, {
            label: string;
            type: "horizontal" | "vertical";
            modelValue: import("./props").ItemBaseType | import("./props").ItemBaseType[];
            error: string;
            tag: import("@dao-style/core").TagType;
            required: boolean;
            controlProps: Record<string, unknown>;
            modelModifiers: Record<string, boolean>;
            yupConcat: import("yup").BaseSchema<any, import("yup/lib/types").AnyObject, any>;
            yupType: import("yup").BaseSchema<any, import("yup/lib/types").AnyObject, any>;
            validationRules: import("vee-validate").RuleExpression<unknown> | import("vue").Ref<import("vee-validate").RuleExpression<unknown>>;
            validationOptions: Partial<import("vee-validate").FieldOptions<unknown>> | undefined;
            componentValidate: boolean;
            custom: boolean;
            wrapperType: "footer" | "switch" | "text" | "checkbox" | "radio" | undefined;
            paddingTop: string | number;
            paddingBottom: string | number;
            labelWidth: string;
            iconMessage: string;
            helper: 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: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
            renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
            errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
        };
        $forceUpdate: () => void;
        $nextTick: typeof import("vue").nextTick;
        $watch<T_1 extends string | ((...args: any) => any)>(source: T_1, cb: T_1 extends (...args: any) => infer R_1 ? (args_0: R_1, args_1: R_1) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
    } & Readonly<import("vue").ExtractPropTypes<{
        modelValue: {
            type: import("vue").PropType<import("./props").ItemBaseType | import("./props").ItemBaseType[]>;
            default: undefined;
        };
        name: {
            type: import("vue").PropType<string>;
        };
        tag: {
            type: import("vue").PropType<import("@dao-style/core").TagType>;
            default: {
                new (...args: any[]): {
                    $: import("vue").ComponentInternalInstance;
                    $data: {};
                    $props: Partial<{
                        type: import("@dao-style/core").InputType;
                        modelValue: import("@dao-style/core").ModalValueType;
                        disabled: boolean;
                        status: import("@dao-style/core").InputStatus;
                        size: import("@dao-style/core").InputSize;
                        block: boolean;
                        borderless: boolean;
                        append: string;
                        prepend: string;
                    }> & Omit<Readonly<import("vue").ExtractPropTypes<{
                        modelValue: {
                            type: import("vue").PropType<import("@dao-style/core").ModalValueType>;
                            default: string;
                        };
                        type: {
                            type: import("vue").PropType<import("@dao-style/core").InputType>;
                            default: string;
                            validator: (value: import("@dao-style/core").InputType) => boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        size: {
                            type: import("vue").PropType<import("@dao-style/core").InputSize>;
                            default: string;
                            validator: (value: import("@dao-style/core").InputSize) => boolean;
                        };
                        block: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        status: {
                            type: import("vue").PropType<import("@dao-style/core").InputStatus>;
                            default: string;
                            validator: (value: import("@dao-style/core").InputStatus) => boolean;
                        };
                        borderless: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        append: {
                            type: StringConstructor;
                            default: string;
                        };
                        prepend: {
                            type: StringConstructor;
                            default: string;
                        };
                        rootAttrs: {
                            type: ObjectConstructor;
                        };
                    }>> & {
                        onFocus?: ((...args: any[]) => any) | undefined;
                        onBlur?: ((...args: any[]) => any) | undefined;
                        onChange?: ((...args: any[]) => any) | undefined;
                        onInput?: ((...args: any[]) => any) | undefined;
                        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                        "onAfter-reset"?: ((...args: any[]) => any) | undefined;
                    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "size" | "type" | "disabled" | "modelValue" | "block" | "status" | "borderless" | "append" | "prepend">;
                    $attrs: {
                        [x: string]: unknown;
                    };
                    $refs: {
                        [x: string]: unknown;
                    };
                    $slots: Readonly<{
                        [name: string]: import("vue").Slot | undefined;
                    }>;
                    $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
                    $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
                    $emit: (event: "input" | "change" | "focus" | "blur" | "update:modelValue" | "after-reset", ...args: any[]) => void;
                    $el: any;
                    $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                        modelValue: {
                            type: import("vue").PropType<import("@dao-style/core").ModalValueType>;
                            default: string;
                        };
                        type: {
                            type: import("vue").PropType<import("@dao-style/core").InputType>;
                            default: string;
                            validator: (value: import("@dao-style/core").InputType) => boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        size: {
                            type: import("vue").PropType<import("@dao-style/core").InputSize>;
                            default: string;
                            validator: (value: import("@dao-style/core").InputSize) => boolean;
                        };
                        block: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        status: {
                            type: import("vue").PropType<import("@dao-style/core").InputStatus>;
                            default: string;
                            validator: (value: import("@dao-style/core").InputStatus) => boolean;
                        };
                        borderless: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        append: {
                            type: StringConstructor;
                            default: string;
                        };
                        prepend: {
                            type: StringConstructor;
                            default: string;
                        };
                        rootAttrs: {
                            type: ObjectConstructor;
                        };
                    }>> & {
                        onFocus?: ((...args: any[]) => any) | undefined;
                        onBlur?: ((...args: any[]) => any) | undefined;
                        onChange?: ((...args: any[]) => any) | undefined;
                        onInput?: ((...args: any[]) => any) | undefined;
                        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                        "onAfter-reset"?: ((...args: any[]) => any) | undefined;
                    }, {
                        currentValue: import("vue").Ref<import("@dao-style/core").ModalValueType>;
                        displayValue: import("vue").ComputedRef<import("@dao-style/core").ModalValueType>;
                        isFocus: import("vue").Ref<boolean>;
                        input: import("vue").Ref<HTMLInputElement | null>;
                        clearable: import("vue").ComputedRef<boolean | "" | 0 | undefined>;
                        wrapClasses: import("vue").ComputedRef<(string | {
                            [x: string]: boolean | "" | 0 | undefined;
                        })[]>;
                        inputClasses: import("vue").ComputedRef<(string | {
                            [x: string]: boolean | import("vue").Slot | undefined;
                        })[]>;
                        inputAttrs: import("vue").ComputedRef<{
                            onInput(event: Event): void;
                            onChange(event: Event): void;
                            onBlur(event: FocusEvent): void;
                            onFocus(event: FocusEvent): void;
                        }>;
                        slots: Readonly<{
                            [name: string]: import("vue").Slot | undefined;
                        }>;
                        resetCurrentVal: () => void;
                        statusClasses: import("vue").ComputedRef<string>;
                        changeNumberValue: (changeType: "increase" | "decrease") => void;
                        isIncreaseDisabled: import("vue").Ref<boolean>;
                        isDecreaseDisabled: import("vue").Ref<boolean>;
                        isChangingNumber: import("vue").Ref<boolean>;
                        inputType: import("vue").ComputedRef<import("@dao-style/core").InputType>;
                        passwordIcon: import("vue").ComputedRef<"icon-eye-slash" | "icon-eye">;
                        toggleShowPassword: () => void;
                    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("input" | "change" | "focus" | "blur" | "update:modelValue" | "after-reset")[], string, {
                        type: import("@dao-style/core").InputType;
                        modelValue: import("@dao-style/core").ModalValueType;
                        disabled: boolean;
                        status: import("@dao-style/core").InputStatus;
                        size: import("@dao-style/core").InputSize;
                        block: boolean;
                        borderless: boolean;
                        append: string;
                        prepend: 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: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[] | undefined;
                        renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[] | undefined;
                        errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[] | undefined;
                    };
                    $forceUpdate: () => void;
                    $nextTick: typeof import("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?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
                } & Readonly<import("vue").ExtractPropTypes<{
                    modelValue: {
                        type: import("vue").PropType<import("@dao-style/core").ModalValueType>;
                        default: string;
                    };
                    type: {
                        type: import("vue").PropType<import("@dao-style/core").InputType>;
                        default: string;
                        validator: (value: import("@dao-style/core").InputType) => boolean;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: import("vue").PropType<import("@dao-style/core").InputSize>;
                        default: string;
                        validator: (value: import("@dao-style/core").InputSize) => boolean;
                    };
                    block: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    status: {
                        type: import("vue").PropType<import("@dao-style/core").InputStatus>;
                        default: string;
                        validator: (value: import("@dao-style/core").InputStatus) => boolean;
                    };
                    borderless: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    append: {
                        type: StringConstructor;
                        default: string;
                    };
                    prepend: {
                        type: StringConstructor;
                        default: string;
                    };
                    rootAttrs: {
                        type: ObjectConstructor;
                    };
                }>> & {
                    onFocus?: ((...args: any[]) => any) | undefined;
                    onBlur?: ((...args: any[]) => any) | undefined;
                    onChange?: ((...args: any[]) => any) | undefined;
                    onInput?: ((...args: any[]) => any) | undefined;
                    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                    "onAfter-reset"?: ((...args: any[]) => any) | undefined;
                } & import("vue").ShallowUnwrapRef<{
                    currentValue: import("vue").Ref<import("@dao-style/core").ModalValueType>;
                    displayValue: import("vue").ComputedRef<import("@dao-style/core").ModalValueType>;
                    isFocus: import("vue").Ref<boolean>;
                    input: import("vue").Ref<HTMLInputElement | null>;
                    clearable: import("vue").ComputedRef<boolean | "" | 0 | undefined>;
                    wrapClasses: import("vue").ComputedRef<(string | {
                        [x: string]: boolean | "" | 0 | undefined;
                    })[]>;
                    inputClasses: import("vue").ComputedRef<(string | {
                        [x: string]: boolean | import("vue").Slot | undefined;
                    })[]>;
                    inputAttrs: import("vue").ComputedRef<{
                        onInput(event: Event): void;
                        onChange(event: Event): void;
                        onBlur(event: FocusEvent): void;
                        onFocus(event: FocusEvent): void;
                    }>;
                    slots: Readonly<{
                        [name: string]: import("vue").Slot | undefined;
                    }>;
                    resetCurrentVal: () => void;
                    statusClasses: import("vue").ComputedRef<string>;
                    changeNumberValue: (changeType: "increase" | "decrease") => void;
                    isIncreaseDisabled: import("vue").Ref<boolean>;
                    isDecreaseDisabled: import("vue").Ref<boolean>;
                    isChangingNumber: import("vue").Ref<boolean>;
                    inputType: import("vue").ComputedRef<import("@dao-style/core").InputType>;
                    passwordIcon: import("vue").ComputedRef<"icon-eye-slash" | "icon-eye">;
                    toggleShowPassword: () => void;
                }> & import("vue").ComponentCustomProperties;
                __isFragment?: undefined;
                __isTeleport?: undefined;
                __isSuspense?: undefined;
            } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                modelValue: {
                    type: import("vue").PropType<import("@dao-style/core").ModalValueType>;
                    default: string;
                };
                type: {
                    type: import("vue").PropType<import("@dao-style/core").InputType>;
                    default: string;
                    validator: (value: import("@dao-style/core").InputType) => boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: import("vue").PropType<import("@dao-style/core").InputSize>;
                    default: string;
                    validator: (value: import("@dao-style/core").InputSize) => boolean;
                };
                block: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                status: {
                    type: import("vue").PropType<import("@dao-style/core").InputStatus>;
                    default: string;
                    validator: (value: import("@dao-style/core").InputStatus) => boolean;
                };
                borderless: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                append: {
                    type: StringConstructor;
                    default: string;
                };
                prepend: {
                    type: StringConstructor;
                    default: string;
                };
                rootAttrs: {
                    type: ObjectConstructor;
                };
            }>> & {
                onFocus?: ((...args: any[]) => any) | undefined;
                onBlur?: ((...args: any[]) => any) | undefined;
                onChange?: ((...args: any[]) => any) | undefined;
                onInput?: ((...args: any[]) => any) | undefined;
                "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                "onAfter-reset"?: ((...args: any[]) => any) | undefined;
            }, {
                currentValue: import("vue").Ref<import("@dao-style/core").ModalValueType>;
                displayValue: import("vue").ComputedRef<import("@dao-style/core").ModalValueType>;
                isFocus: import("vue").Ref<boolean>;
                input: import("vue").Ref<HTMLInputElement | null>;
                clearable: import("vue").ComputedRef<boolean | "" | 0 | undefined>;
                wrapClasses: import("vue").ComputedRef<(string | {
                    [x: string]: boolean | "" | 0 | undefined;
                })[]>;
                inputClasses: import("vue").ComputedRef<(string | {
                    [x: string]: boolean | import("vue").Slot | undefined;
                })[]>;
                inputAttrs: import("vue").ComputedRef<{
                    onInput(event: Event): void;
                    onChange(event: Event): void;
                    onBlur(event: FocusEvent): void;
                    onFocus(event: FocusEvent): void;
                }>;
                slots: Readonly<{
                    [name: string]: import("vue").Slot | undefined;
                }>;
                resetCurrentVal: () => void;
                statusClasses: import("vue").ComputedRef<string>;
                changeNumberValue: (changeType: "increase" | "decrease") => void;
                isIncreaseDisabled: import("vue").Ref<boolean>;
                isDecreaseDisabled: import("vue").Ref<boolean>;
                isChangingNumber: import("vue").Ref<boolean>;
                inputType: import("vue").ComputedRef<import("@dao-style/core").InputType>;
                passwordIcon: import("vue").ComputedRef<"icon-eye-slash" | "icon-eye">;
                toggleShowPassword: () => void;
            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("input" | "change" | "focus" | "blur" | "update:modelValue" | "after-reset")[], "input" | "change" | "focus" | "blur" | "update:modelValue" | "after-reset", {
                type: import("@dao-style/core").InputType;
                modelValue: import("@dao-style/core").ModalValueType;
                disabled: boolean;
                status: import("@dao-style/core").InputStatus;
                size: import("@dao-style/core").InputSize;
                block: boolean;
                borderless: boolean;
                append: string;
                prepend: string;
            }, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
                $props: Partial<import("@dao-style/core").InputProps>;
                $slots: {
                    prefix: import("@dao-style/core").SlotFn;
                    suffix: import("@dao-style/core").SlotFn;
                    prepend: import("@dao-style/core").SlotFn;
                    append: import("@dao-style/core").SlotFn;
                };
            });
        };
        controlProps: {
            type: import("vue").PropType<Record<string, unknown>>;
            default: undefined;
        };
        modelModifiers: {
            type: import("vue").PropType<Record<string, boolean>>;
            default: undefined;
        };
        yupConcat: {
            type: import("vue").PropType<import("yup").BaseSchema<any, import("yup/lib/types").AnyObject, any>>;
            default: undefined;
        };
        yupType: {
            type: import("vue").PropType<import("yup").BaseSchema<any, import("yup/lib/types").AnyObject, any>>;
            default: undefined;
        };
        validationRules: {
            type: import("vue").PropType<import("vee-validate").RuleExpression<unknown> | import("vue").Ref<import("vee-validate").RuleExpression<unknown>>>;
            default: undefined;
        };
        validationOptions: {
            type: import("vue").PropType<Partial<import("vee-validate").FieldOptions<unknown>> | undefined>;
            default: undefined;
        };
        componentValidate: {
            type: BooleanConstructor;
            default: boolean;
        };
        custom: {
            type: BooleanConstructor;
            default: boolean;
        };
        label: {
            type: import("vue").PropType<string>;
            default: string;
        };
        required: {
            type: import("vue").PropType<boolean>;
            default: boolean;
        };
        wrapperType: {
            type: import("vue").PropType<"footer" | "switch" | "text" | "checkbox" | "radio" | undefined>;
            default: undefined;
        };
        paddingTop: {
            type: import("vue").PropType<string | number>;
            default: number;
        };
        paddingBottom: {
            type: import("vue").PropType<string | number>;
            default: number;
        };
        labelWidth: {
            type: import("vue").PropType<string>;
            default: string;
        };
        iconMessage: {
            type: import("vue").PropType<string>;
            default: string;
        };
        helper: {
            type: import("vue").PropType<string>;
            default: undefined;
        };
        error: {
            type: import("vue").PropType<string>;
            default: undefined;
        };
        type: {
            type: import("vue").PropType<"horizontal" | "vertical">;
            default: undefined;
        };
    }>> & {
        "onUpdate:modelValue"?: ((value: unknown) => any) | undefined;
        onChange?: ((value: unknown) => any) | undefined;
    } & import("vue").ShallowUnwrapRef<{
        currentControlProps: import("vue").ComputedRef<{
            modelModifiers: Record<string, boolean> | undefined;
        }>;
        currentRules: import("vue").ComputedRef<string | Record<string, unknown> | import("yup").BaseSchema<any, import("yup/lib/types").AnyObject, any> | import("vee-validate").GenericValidateFunction<unknown> | import("vee-validate").GenericValidateFunction<unknown>[] | import("vue").Ref<import("vee-validate").RuleExpression<unknown>> | import("yup").NumberSchema<number | undefined, import("yup/lib/types").AnyObject, number | undefined> | import("yup").StringSchema<string | undefined, import("yup/lib/types").AnyObject, string | undefined>>;
        fieldReturn: FieldContext<any>;
        currentValue: import("vue").Ref<any>;
        hasErrorMessage: import("vue").ComputedRef<boolean>;
        status: import("vue").ComputedRef<"default" | "error">;
        controlSlots: import("vue").ComputedRef<import("lodash").Omit<Readonly<{
            [name: string]: import("vue").Slot | undefined;
        }>, string>>;
        formItemPropsObject: import("vue").ComputedRef<{
            [k: string]: string | number | boolean | undefined;
        }>;
    }> & {} & import("vue").ComponentCustomProperties & {};
    __isFragment?: undefined;
    __isTeleport?: undefined;
    __isSuspense?: undefined;
} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
    modelValue: {
        type: import("vue").PropType<import("./props").ItemBaseType | import("./props").ItemBaseType[]>;
        default: undefined;
    };
    name: {
        type: import("vue").PropType<string>;
    };
    tag: {
        type: import("vue").PropType<import("@dao-style/core").TagType>;
        default: {
            new (...args: any[]): {
                $: import("vue").ComponentInternalInstance;
                $data: {};
                $props: Partial<{
                    type: import("@dao-style/core").InputType;
                    modelValue: import("@dao-style/core").ModalValueType;
                    disabled: boolean;
                    status: import("@dao-style/core").InputStatus;
                    size: import("@dao-style/core").InputSize;
                    block: boolean;
                    borderless: boolean;
                    append: string;
                    prepend: string;
                }> & Omit<Readonly<import("vue").ExtractPropTypes<{
                    modelValue: {
                        type: import("vue").PropType<import("@dao-style/core").ModalValueType>;
                        default: string;
                    };
                    type: {
                        type: import("vue").PropType<import("@dao-style/core").InputType>;
                        default: string;
                        validator: (value: import("@dao-style/core").InputType) => boolean;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: import("vue").PropType<import("@dao-style/core").InputSize>;
                        default: string;
                        validator: (value: import("@dao-style/core").InputSize) => boolean;
                    };
                    block: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    status: {
                        type: import("vue").PropType<import("@dao-style/core").InputStatus>;
                        default: string;
                        validator: (value: import("@dao-style/core").InputStatus) => boolean;
                    };
                    borderless: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    append: {
                        type: StringConstructor;
                        default: string;
                    };
                    prepend: {
                        type: StringConstructor;
                        default: string;
                    };
                    rootAttrs: {
                        type: ObjectConstructor;
                    };
                }>> & {
                    onFocus?: ((...args: any[]) => any) | undefined;
                    onBlur?: ((...args: any[]) => any) | undefined;
                    onChange?: ((...args: any[]) => any) | undefined;
                    onInput?: ((...args: any[]) => any) | undefined;
                    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                    "onAfter-reset"?: ((...args: any[]) => any) | undefined;
                } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "size" | "type" | "disabled" | "modelValue" | "block" | "status" | "borderless" | "append" | "prepend">;
                $attrs: {
                    [x: string]: unknown;
                };
                $refs: {
                    [x: string]: unknown;
                };
                $slots: Readonly<{
                    [name: string]: import("vue").Slot | undefined;
                }>;
                $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
                $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
                $emit: (event: "input" | "change" | "focus" | "blur" | "update:modelValue" | "after-reset", ...args: any[]) => void;
                $el: any;
                $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                    modelValue: {
                        type: import("vue").PropType<import("@dao-style/core").ModalValueType>;
                        default: string;
                    };
                    type: {
                        type: import("vue").PropType<import("@dao-style/core").InputType>;
                        default: string;
                        validator: (value: import("@dao-style/core").InputType) => boolean;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: import("vue").PropType<import("@dao-style/core").InputSize>;
                        default: string;
                        validator: (value: import("@dao-style/core").InputSize) => boolean;
                    };
                    block: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    status: {
                        type: import("vue").PropType<import("@dao-style/core").InputStatus>;
                        default: string;
                        validator: (value: import("@dao-style/core").InputStatus) => boolean;
                    };
                    borderless: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    append: {
                        type: StringConstructor;
                        default: string;
                    };
                    prepend: {
                        type: StringConstructor;
                        default: string;
                    };
                    rootAttrs: {
                        type: ObjectConstructor;
                    };
                }>> & {
                    onFocus?: ((...args: any[]) => any) | undefined;
                    onBlur?: ((...args: any[]) => any) | undefined;
                    onChange?: ((...args: any[]) => any) | undefined;
                    onInput?: ((...args: any[]) => any) | undefined;
                    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                    "onAfter-reset"?: ((...args: any[]) => any) | undefined;
                }, {
                    currentValue: import("vue").Ref<import("@dao-style/core").ModalValueType>;
                    displayValue: import("vue").ComputedRef<import("@dao-style/core").ModalValueType>;
                    isFocus: import("vue").Ref<boolean>;
                    input: import("vue").Ref<HTMLInputElement | null>;
                    clearable: import("vue").ComputedRef<boolean | "" | 0 | undefined>;
                    wrapClasses: import("vue").ComputedRef<(string | {
                        [x: string]: boolean | "" | 0 | undefined;
                    })[]>;
                    inputClasses: import("vue").ComputedRef<(string | {
                        [x: string]: boolean | import("vue").Slot | undefined;
                    })[]>;
                    inputAttrs: import("vue").ComputedRef<{
                        onInput(event: Event): void;
                        onChange(event: Event): void;
                        onBlur(event: FocusEvent): void;
                        onFocus(event: FocusEvent): void;
                    }>;
                    slots: Readonly<{
                        [name: string]: import("vue").Slot | undefined;
                    }>;
                    resetCurrentVal: () => void;
                    statusClasses: import("vue").ComputedRef<string>;
                    changeNumberValue: (changeType: "increase" | "decrease") => void;
                    isIncreaseDisabled: import("vue").Ref<boolean>;
                    isDecreaseDisabled: import("vue").Ref<boolean>;
                    isChangingNumber: import("vue").Ref<boolean>;
                    inputType: import("vue").ComputedRef<import("@dao-style/core").InputType>;
                    passwordIcon: import("vue").ComputedRef<"icon-eye-slash" | "icon-eye">;
                    toggleShowPassword: () => void;
                }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("input" | "change" | "focus" | "blur" | "update:modelValue" | "after-reset")[], string, {
                    type: import("@dao-style/core").InputType;
                    modelValue: import("@dao-style/core").ModalValueType;
                    disabled: boolean;
                    status: import("@dao-style/core").InputStatus;
                    size: import("@dao-style/core").InputSize;
                    block: boolean;
                    borderless: boolean;
                    append: string;
                    prepend: 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: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[] | undefined;
                    renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[] | undefined;
                    errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[] | undefined;
                };
                $forceUpdate: () => void;
                $nextTick: typeof import("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?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
            } & Readonly<import("vue").ExtractPropTypes<{
                modelValue: {
                    type: import("vue").PropType<import("@dao-style/core").ModalValueType>;
                    default: string;
                };
                type: {
                    type: import("vue").PropType<import("@dao-style/core").InputType>;
                    default: string;
                    validator: (value: import("@dao-style/core").InputType) => boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: import("vue").PropType<import("@dao-style/core").InputSize>;
                    default: string;
                    validator: (value: import("@dao-style/core").InputSize) => boolean;
                };
                block: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                status: {
                    type: import("vue").PropType<import("@dao-style/core").InputStatus>;
                    default: string;
                    validator: (value: import("@dao-style/core").InputStatus) => boolean;
                };
                borderless: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                append: {
                    type: StringConstructor;
                    default: string;
                };
                prepend: {
                    type: StringConstructor;
                    default: string;
                };
                rootAttrs: {
                    type: ObjectConstructor;
                };
            }>> & {
                onFocus?: ((...args: any[]) => any) | undefined;
                onBlur?: ((...args: any[]) => any) | undefined;
                onChange?: ((...args: any[]) => any) | undefined;
                onInput?: ((...args: any[]) => any) | undefined;
                "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                "onAfter-reset"?: ((...args: any[]) => any) | undefined;
            } & import("vue").ShallowUnwrapRef<{
                currentValue: import("vue").Ref<import("@dao-style/core").ModalValueType>;
                displayValue: import("vue").ComputedRef<import("@dao-style/core").ModalValueType>;
                isFocus: import("vue").Ref<boolean>;
                input: import("vue").Ref<HTMLInputElement | null>;
                clearable: import("vue").ComputedRef<boolean | "" | 0 | undefined>;
                wrapClasses: import("vue").ComputedRef<(string | {
                    [x: string]: boolean | "" | 0 | undefined;
                })[]>;
                inputClasses: import("vue").ComputedRef<(string | {
                    [x: string]: boolean | import("vue").Slot | undefined;
                })[]>;
                inputAttrs: import("vue").ComputedRef<{
                    onInput(event: Event): void;
                    onChange(event: Event): void;
                    onBlur(event: FocusEvent): void;
                    onFocus(event: FocusEvent): void;
                }>;
                slots: Readonly<{
                    [name: string]: import("vue").Slot | undefined;
                }>;
                resetCurrentVal: () => void;
                statusClasses: import("vue").ComputedRef<string>;
                changeNumberValue: (changeType: "increase" | "decrease") => void;
                isIncreaseDisabled: import("vue").Ref<boolean>;
                isDecreaseDisabled: import("vue").Ref<boolean>;
                isChangingNumber: import("vue").Ref<boolean>;
                inputType: import("vue").ComputedRef<import("@dao-style/core").InputType>;
                passwordIcon: import("vue").ComputedRef<"icon-eye-slash" | "icon-eye">;
                toggleShowPassword: () => void;
            }> & import("vue").ComponentCustomProperties;
            __isFragment?: undefined;
            __isTeleport?: undefined;
            __isSuspense?: undefined;
        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
            modelValue: {
                type: import("vue").PropType<import("@dao-style/core").ModalValueType>;
                default: string;
            };
            type: {
                type: import("vue").PropType<import("@dao-style/core").InputType>;
                default: string;
                validator: (value: import("@dao-style/core").InputType) => boolean;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: import("vue").PropType<import("@dao-style/core").InputSize>;
                default: string;
                validator: (value: import("@dao-style/core").InputSize) => boolean;
            };
            block: {
                type: BooleanConstructor;
                default: boolean;
            };
            status: {
                type: import("vue").PropType<import("@dao-style/core").InputStatus>;
                default: string;
                validator: (value: import("@dao-style/core").InputStatus) => boolean;
            };
            borderless: {
                type: BooleanConstructor;
                default: boolean;
            };
            append: {
                type: StringConstructor;
                default: string;
            };
            prepend: {
                type: StringConstructor;
                default: string;
            };
            rootAttrs: {
                type: ObjectConstructor;
            };
        }>> & {
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onChange?: ((...args: any[]) => any) | undefined;
            onInput?: ((...args: any[]) => any) | undefined;
            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
            "onAfter-reset"?: ((...args: any[]) => any) | undefined;
        }, {
            currentValue: import("vue").Ref<import("@dao-style/core").ModalValueType>;
            displayValue: import("vue").ComputedRef<import("@dao-style/core").ModalValueType>;
            isFocus: import("vue").Ref<boolean>;
            input: import("vue").Ref<HTMLInputElement | null>;
            clearable: import("vue").ComputedRef<boolean | "" | 0 | undefined>;
            wrapClasses: import("vue").ComputedRef<(string | {
                [x: string]: boolean | "" | 0 | undefined;
            })[]>;
            inputClasses: import("vue").ComputedRef<(string | {
                [x: string]: boolean | import("vue").Slot | undefined;
            })[]>;
            inputAttrs: import("vue").ComputedRef<{
                onInput(event: Event): void;
                onChange(event: Event): void;
                onBlur(event: FocusEvent): void;
                onFocus(event: FocusEvent): void;
            }>;
            slots: Readonly<{
                [name: string]: import("vue").Slot | undefined;
            }>;
            resetCurrentVal: () => void;
            statusClasses: import("vue").ComputedRef<string>;
            changeNumberValue: (changeType: "increase" | "decrease") => void;
            isIncreaseDisabled: import("vue").Ref<boolean>;
            isDecreaseDisabled: import("vue").Ref<boolean>;
            isChangingNumber: import("vue").Ref<boolean>;
            inputType: import("vue").ComputedRef<import("@dao-style/core").InputType>;
            passwordIcon: import("vue").ComputedRef<"icon-eye-slash" | "icon-eye">;
            toggleShowPassword: () => void;
        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("input" | "change" | "focus" | "blur" | "update:modelValue" | "after-reset")[], "input" | "change" | "focus" | "blur" | "update:modelValue" | "after-reset", {
            type: import("@dao-style/core").InputType;
            modelValue: import("@dao-style/core").ModalValueType;
            disabled: boolean;
            status: import("@dao-style/core").InputStatus;
            size: import("@dao-style/core").InputSize;
            block: boolean;
            borderless: boolean;
            append: string;
            prepend: string;
        }, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
            $props: Partial<import("@dao-style/core").InputProps>;
            $slots: {
                prefix: import("@dao-style/core").SlotFn;
                suffix: import("@dao-style/core").SlotFn;
                prepend: import("@dao-style/core").SlotFn;
                append: import("@dao-style/core").SlotFn;
            };
        });
    };
    controlProps: {
        type: import("vue").PropType<Record<string, unknown>>;
        default: undefined;
    };
    modelModifiers: {
        type: import("vue").PropType<Record<string, boolean>>;
        default: undefined;
    };
    yupConcat: {
        type: import("vue").PropType<import("yup").BaseSchema<any, import("yup/lib/types").AnyObject, any>>;
        default: undefined;
    };
    yupType: {
        type: import("vue").PropType<import("yup").BaseSchema<any, import("yup/lib/types").AnyObject, any>>;
        default: undefined;
    };
    validationRules: {
        type: import("vue").PropType<import("vee-validate").RuleExpression<unknown> | import("vue").Ref<import("vee-validate").RuleExpression<unknown>>>;
        default: undefined;
    };
    validationOptions: {
        type: import("vue").PropType<Partial<import("vee-validate").FieldOptions<unknown>> | undefined>;
        default: undefined;
    };
    componentValidate: {
        type: BooleanConstructor;
        default: boolean;
    };
    custom: {
        type: BooleanConstructor;
        default: boolean;
    };
    label: {
        type: import("vue").PropType<string>;
        default: string;
    };
    required: {
        type: import("vue").PropType<boolean>;
        default: boolean;
    };
    wrapperType: {
        type: import("vue").PropType<"footer" | "switch" | "text" | "checkbox" | "radio" | undefined>;
        default: undefined;
    };
    paddingTop: {
        type: import("vue").PropType<string | number>;
        default: number;
    };
    paddingBottom: {
        type: import("vue").PropType<string | number>;
        default: number;
    };
    labelWidth: {
        type: import("vue").PropType<string>;
        default: string;
    };
    iconMessage: {
        type: import("vue").PropType<string>;
        default: string;
    };
    helper: {
        type: import("vue").PropType<string>;
        default: undefined;
    };
    error: {
        type: import("vue").PropType<string>;
        default: undefined;
    };
    type: {
        type: import("vue").PropType<"horizontal" | "vertical">;
        default: undefined;
    };
}>> & {
    "onUpdate:modelValue"?: ((value: unknown) => any) | undefined;
    onChange?: ((value: unknown) => any) | undefined;
}, {
    currentControlProps: import("vue").ComputedRef<{
        modelModifiers: Record<string, boolean> | undefined;
    }>;
    currentRules: import("vue").ComputedRef<string | Record<string, unknown> | import("yup").BaseSchema<any, import("yup/lib/types").AnyObject, any> | import("vee-validate").GenericValidateFunction<unknown> | import("vee-validate").GenericValidateFunction<unknown>[] | import("vue").Ref<import("vee-validate").RuleExpression<unknown>> | import("yup").NumberSchema<number | undefined, import("yup/lib/types").AnyObject, number | undefined> | import("yup").StringSchema<string | undefined, import("yup/lib/types").AnyObject, string | undefined>>;
    fieldReturn: FieldContext<any>;
    currentValue: import("vue").Ref<any>;
    hasErrorMessage: import("vue").ComputedRef<boolean>;
    status: import("vue").ComputedRef<"default" | "error">;
    controlSlots: import("vue").ComputedRef<import("lodash").Omit<Readonly<{
        [name: string]: import("vue").Slot | undefined;
    }>, string>>;
    formItemPropsObject: import("vue").ComputedRef<{
        [k: string]: string | number | boolean | undefined;
    }>;
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
    'update:modelValue': (value: unknown) => void;
    change: (value: unknown) => void;
}, string, {
    label: string;
    type: "horizontal" | "vertical";
    modelValue: import("./props").ItemBaseType | import("./props").ItemBaseType[];
    error: string;
    tag: import("@dao-style/core").TagType;
    required: boolean;
    controlProps: Record<string, unknown>;
    modelModifiers: Record<string, boolean>;
    yupConcat: import("yup").BaseSchema<any, import("yup/lib/types").AnyObject, any>;
    yupType: import("yup").BaseSchema<any, import("yup/lib/types").AnyObject, any>;
    validationRules: import("vee-validate").RuleExpression<unknown> | import("vue").Ref<import("vee-validate").RuleExpression<unknown>>;
    validationOptions: Partial<import("vee-validate").FieldOptions<unknown>> | undefined;
    componentValidate: boolean;
    custom: boolean;
    wrapperType: "footer" | "switch" | "text" | "checkbox" | "radio" | undefined;
    paddingTop: string | number;
    paddingBottom: string | number;
    labelWidth: string;
    iconMessage: string;
    helper: string;
}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new <T_2>(props: {
    tag: T_2;
}) => {
    $slots: {
        label: FieldReturnSlotFn;
        'control-content': FieldReturnSlotFn<{
            status: Status;
            componentRef: any;
        }>;
        error: FieldReturnSlotFn;
        helper: FieldReturnSlotFn;
    } & GetSlots<T_2>;
});
export default _default;