@xdmp-open/ui-admin 0.1.0

package/dist/modules/system-open/detail.vue.d.ts

@@ -0,0 +1,1910 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {
+    appList: any[];
+    detail: Record<string, any>;
+    appId: string;
+    appKeys: {};
+    phone: string;
+    loading: boolean;
+    pageDataInfo: ({
+        label: string;
+        key: string;
+        operation?: undefined;
+    } | {
+        label: string;
+        key: string;
+        operation: string;
+    })[];
+}, {}, {
+    init(): void;
+    accesskey(e: any): void;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
+    pageDataInfo: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        isBack: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        isEdit: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        keys: {
+            type: ObjectConstructor;
+            default: () => void;
+        };
+        info: {
+            type: ArrayConstructor;
+            default: () => never[];
+        };
+        icon: {
+            type: StringConstructor;
+            default: string;
+        };
+        title: {
+            type: StringConstructor;
+            default: string;
+        };
+        labelWidth: {
+            type: StringConstructor;
+            default: string;
+        };
+        labelAlign: {
+            type: StringConstructor;
+            default: string;
+        };
+        showColon: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>, {}, {
+        showSensitiveData: Record<string, boolean>;
+    }, {
+        omit(): boolean;
+        list(): any[];
+    }, {
+        formatData(val: any): any;
+        back(): void;
+        Accesskey(e: string): void;
+        edit(): void;
+        popup(): void;
+        handleEditLabel(key: string): void;
+        goProduct(e: Event): void;
+        handleCopy(): void;
+        editOffline(item: any): void;
+        changeRegistration(e: any): void;
+        handleMouseDown(v: string): void;
+        handleMouseUp(v: string): void;
+        editValue(): void;
+        updateValue(): void;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("updateValue" | "edit" | "accesskey" | "editOffline" | "changeRegistration" | "popup" | "editLabel" | "editValue")[], "updateValue" | "edit" | "accesskey" | "editOffline" | "changeRegistration" | "popup" | "editLabel" | "editValue", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        isBack: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        isEdit: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        keys: {
+            type: ObjectConstructor;
+            default: () => void;
+        };
+        info: {
+            type: ArrayConstructor;
+            default: () => never[];
+        };
+        icon: {
+            type: StringConstructor;
+            default: string;
+        };
+        title: {
+            type: StringConstructor;
+            default: string;
+        };
+        labelWidth: {
+            type: StringConstructor;
+            default: string;
+        };
+        labelAlign: {
+            type: StringConstructor;
+            default: string;
+        };
+        showColon: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        onEdit?: ((...args: any[]) => any) | undefined;
+        onUpdateValue?: ((...args: any[]) => any) | undefined;
+        onAccesskey?: ((...args: any[]) => any) | undefined;
+        onEditOffline?: ((...args: any[]) => any) | undefined;
+        onChangeRegistration?: ((...args: any[]) => any) | undefined;
+        onPopup?: ((...args: any[]) => any) | undefined;
+        onEditLabel?: ((...args: any[]) => any) | undefined;
+        onEditValue?: ((...args: any[]) => any) | undefined;
+    }>, {
+        keys: Record<string, any>;
+        title: string;
+        icon: string;
+        info: unknown[];
+        labelWidth: string;
+        isBack: boolean;
+        isEdit: boolean;
+        labelAlign: string;
+        showColon: boolean;
+    }, {}, {
+        DocumentCopy: import('vue').DefineComponent<{}, void, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        Edit: import('vue').DefineComponent<{}, void, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        View: import('vue').DefineComponent<{}, void, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        Hide: import('vue').DefineComponent<{}, void, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        ElButton: {
+            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').ButtonProps> & Readonly<{
+                onClick?: ((evt: MouseEvent) => any) | undefined;
+            }>, {
+                ref: import('vue').Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+                size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                type: import('vue').ComputedRef<"" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
+                disabled: import('vue').ComputedRef<boolean>;
+                shouldAddSpace: import('vue').ComputedRef<boolean>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                click: (evt: MouseEvent) => void;
+            }, import('vue').PublicProps, {
+                type: import('element-plus').ButtonType;
+                text: boolean;
+                disabled: boolean;
+                round: boolean;
+                dashed: boolean;
+                nativeType: import('element-plus').ButtonNativeType;
+                loadingIcon: import('element-plus/es/utils/vue/icon.mjs').IconPropType;
+                plain: boolean;
+                autoInsertSpace: boolean;
+                tag: string | import('vue').Component;
+            }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import('element-plus').ButtonProps> & Readonly<{
+                onClick?: ((evt: MouseEvent) => any) | undefined;
+            }>, {
+                ref: import('vue').Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+                size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                type: import('vue').ComputedRef<"" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
+                disabled: import('vue').ComputedRef<boolean>;
+                shouldAddSpace: import('vue').ComputedRef<boolean>;
+            }, {}, {}, {}, {
+                type: import('element-plus').ButtonType;
+                text: boolean;
+                disabled: boolean;
+                round: boolean;
+                dashed: boolean;
+                nativeType: import('element-plus').ButtonNativeType;
+                loadingIcon: import('element-plus/es/utils/vue/icon.mjs').IconPropType;
+                plain: boolean;
+                autoInsertSpace: boolean;
+                tag: string | import('vue').Component;
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').ButtonProps> & Readonly<{
+            onClick?: ((evt: MouseEvent) => any) | undefined;
+        }>, {
+            ref: import('vue').Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+            size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+            type: import('vue').ComputedRef<"" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
+            disabled: import('vue').ComputedRef<boolean>;
+            shouldAddSpace: import('vue').ComputedRef<boolean>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            click: (evt: MouseEvent) => void;
+        }, string, {
+            type: import('element-plus').ButtonType;
+            text: boolean;
+            disabled: boolean;
+            round: boolean;
+            dashed: boolean;
+            nativeType: import('element-plus').ButtonNativeType;
+            loadingIcon: import('element-plus/es/utils/vue/icon.mjs').IconPropType;
+            plain: boolean;
+            autoInsertSpace: boolean;
+            tag: string | import('vue').Component;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+            $slots: {
+                loading?: (props: {}) => any;
+            } & {
+                icon?: (props: {}) => any;
+            } & {
+                default?: (props: {}) => any;
+            };
+        }) & import('vue').ObjectPlugin & {
+            setPropsDefaults: (defaults: {
+                readonly size?: "" | "default" | "small" | "large" | (() => "" | "default" | "small" | "large") | undefined;
+                readonly disabled?: boolean | (() => boolean) | undefined;
+                readonly type?: "" | "text" | "default" | "primary" | "success" | "warning" | "info" | "danger" | (() => "" | "text" | "default" | "primary" | "success" | "warning" | "info" | "danger") | undefined;
+                readonly icon?: string | import('vue').FunctionalComponent<any, {}, any, {}> | {
+                    new (...args: any[]): any;
+                    __isFragment?: never;
+                    __isTeleport?: never;
+                    __isSuspense?: never;
+                } | (() => (import('element-plus/es/utils/vue/icon.mjs').IconPropType | undefined) & {}) | undefined;
+                readonly nativeType?: "button" | "submit" | "reset" | (() => "button" | "submit" | "reset") | undefined;
+                readonly loading?: boolean | (() => boolean) | undefined;
+                readonly loadingIcon?: string | import('vue').FunctionalComponent<any, {}, any, {}> | {
+                    new (...args: any[]): any;
+                    __isFragment?: never;
+                    __isTeleport?: never;
+                    __isSuspense?: never;
+                } | (() => (import('element-plus/es/utils/vue/icon.mjs').IconPropType | undefined) & {}) | undefined;
+                readonly plain?: boolean | (() => boolean) | undefined;
+                readonly text?: boolean | (() => boolean) | undefined;
+                readonly link?: boolean | (() => boolean) | undefined;
+                readonly bg?: boolean | (() => boolean) | undefined;
+                readonly autofocus?: boolean | (() => boolean) | undefined;
+                readonly round?: boolean | (() => boolean) | undefined;
+                readonly circle?: boolean | (() => boolean) | undefined;
+                readonly dashed?: boolean | (() => boolean) | undefined;
+                readonly color?: string | (() => string) | undefined;
+                readonly dark?: boolean | (() => boolean) | undefined;
+                readonly autoInsertSpace?: boolean | (() => boolean) | undefined;
+                readonly tag?: string | import('vue').FunctionalComponent<any, {}, any, {}> | {
+                    new (...args: any[]): any;
+                    __isFragment?: never;
+                    __isTeleport?: never;
+                    __isSuspense?: never;
+                } | (() => (string | import('vue').Component | undefined) & {}) | undefined;
+            }) => void;
+        } & {
+            ButtonGroup: {
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus/es/components/button/src/button-group.mjs').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+                    direction: "horizontal" | "vertical";
+                    type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
+                }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('element-plus/es/components/button/src/button-group.mjs').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, {
+                    direction: "horizontal" | "vertical";
+                    type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('element-plus/es/components/button/src/button-group.mjs').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                direction: "horizontal" | "vertical";
+                type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    default?: (props: {}) => any;
+                };
+            });
+        };
+        ElIcon: import('element-plus/es/utils/vue/typescript.mjs').SFCWithInstall<{
+            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').IconProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import('element-plus').IconProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').IconProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+            $slots: {
+                default?: (props: {}) => any;
+            };
+        })>;
+        ElTooltip: import('element-plus/es/utils/vue/typescript.mjs').SFCWithInstall<{
+            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').UseTooltipProps> & Readonly<{
+                onOpen?: ((...args: any[]) => any) | undefined;
+                onClose?: ((...args: any[]) => any) | undefined;
+                onHide?: ((...args: any[]) => any) | undefined;
+                onShow?: ((...args: any[]) => any) | undefined;
+                "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
+                "onBefore-show"?: ((...args: any[]) => any) | undefined;
+                "onBefore-hide"?: ((...args: any[]) => any) | undefined;
+            }>, {
+                popperRef: import('vue').Ref<import('element-plus').PopperInstance | undefined, import('element-plus').PopperInstance | undefined>;
+                contentRef: import('vue').Ref<import('element-plus').TooltipContentInstance | undefined, import('element-plus').TooltipContentInstance | undefined>;
+                isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+                updatePopper: () => void;
+                onOpen: (event?: Event, delay?: number) => void;
+                onClose: (event?: Event, delay?: number) => void;
+                hide: (event?: Event) => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                open: (...args: any[]) => void;
+                close: (...args: any[]) => void;
+                hide: (...args: any[]) => void;
+                show: (...args: any[]) => void;
+                "update:visible": (...args: any[]) => void;
+                "before-show": (...args: any[]) => void;
+                "before-hide": (...args: any[]) => void;
+            }, import('vue').PublicProps, {
+                visible: boolean | null;
+                offset: number;
+                teleported: boolean;
+                effect: import('element-plus').PopperEffect;
+                content: string;
+                style: string | false | import('vue').CSSProperties | import('vue').StyleValue[] | null;
+                enterable: boolean;
+                pure: boolean;
+                focusOnShow: boolean;
+                trapping: boolean;
+                popperClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                popperStyle: string | false | import('vue').CSSProperties | import('vue').StyleValue[] | null;
+                stopPopperMouseEvent: boolean;
+                virtualTriggering: boolean;
+                loop: boolean;
+                boundariesPadding: number;
+                gpuAcceleration: boolean;
+                placement: import('element-plus').Placement;
+                popperOptions: Partial<import('element-plus').Options>;
+                strategy: "fixed" | "absolute";
+                arrowOffset: number;
+                showArrow: boolean;
+                role: "dialog" | "menu" | "tree" | "grid" | "group" | "listbox" | "navigation" | "tooltip";
+                showAfter: number;
+                hideAfter: number;
+                autoClose: number;
+                trigger: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').TooltipTriggerType>;
+                triggerKeys: string[];
+            }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import('element-plus').UseTooltipProps> & Readonly<{
+                onOpen?: ((...args: any[]) => any) | undefined;
+                onClose?: ((...args: any[]) => any) | undefined;
+                onHide?: ((...args: any[]) => any) | undefined;
+                onShow?: ((...args: any[]) => any) | undefined;
+                "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
+                "onBefore-show"?: ((...args: any[]) => any) | undefined;
+                "onBefore-hide"?: ((...args: any[]) => any) | undefined;
+            }>, {
+                popperRef: import('vue').Ref<import('element-plus').PopperInstance | undefined, import('element-plus').PopperInstance | undefined>;
+                contentRef: import('vue').Ref<import('element-plus').TooltipContentInstance | undefined, import('element-plus').TooltipContentInstance | undefined>;
+                isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+                updatePopper: () => void;
+                onOpen: (event?: Event, delay?: number) => void;
+                onClose: (event?: Event, delay?: number) => void;
+                hide: (event?: Event) => void;
+            }, {}, {}, {}, {
+                visible: boolean | null;
+                offset: number;
+                teleported: boolean;
+                effect: import('element-plus').PopperEffect;
+                content: string;
+                style: string | false | import('vue').CSSProperties | import('vue').StyleValue[] | null;
+                enterable: boolean;
+                pure: boolean;
+                focusOnShow: boolean;
+                trapping: boolean;
+                popperClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                popperStyle: string | false | import('vue').CSSProperties | import('vue').StyleValue[] | null;
+                stopPopperMouseEvent: boolean;
+                virtualTriggering: boolean;
+                loop: boolean;
+                boundariesPadding: number;
+                gpuAcceleration: boolean;
+                placement: import('element-plus').Placement;
+                popperOptions: Partial<import('element-plus').Options>;
+                strategy: "fixed" | "absolute";
+                arrowOffset: number;
+                showArrow: boolean;
+                role: "dialog" | "menu" | "tree" | "grid" | "group" | "listbox" | "navigation" | "tooltip";
+                showAfter: number;
+                hideAfter: number;
+                autoClose: number;
+                trigger: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').TooltipTriggerType>;
+                triggerKeys: string[];
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').UseTooltipProps> & Readonly<{
+            onOpen?: ((...args: any[]) => any) | undefined;
+            onClose?: ((...args: any[]) => any) | undefined;
+            onHide?: ((...args: any[]) => any) | undefined;
+            onShow?: ((...args: any[]) => any) | undefined;
+            "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
+            "onBefore-show"?: ((...args: any[]) => any) | undefined;
+            "onBefore-hide"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            popperRef: import('vue').Ref<import('element-plus').PopperInstance | undefined, import('element-plus').PopperInstance | undefined>;
+            contentRef: import('vue').Ref<import('element-plus').TooltipContentInstance | undefined, import('element-plus').TooltipContentInstance | undefined>;
+            isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+            updatePopper: () => void;
+            onOpen: (event?: Event, delay?: number) => void;
+            onClose: (event?: Event, delay?: number) => void;
+            hide: (event?: Event) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            open: (...args: any[]) => void;
+            close: (...args: any[]) => void;
+            hide: (...args: any[]) => void;
+            show: (...args: any[]) => void;
+            "update:visible": (...args: any[]) => void;
+            "before-show": (...args: any[]) => void;
+            "before-hide": (...args: any[]) => void;
+        }, string, {
+            visible: boolean | null;
+            offset: number;
+            teleported: boolean;
+            effect: import('element-plus').PopperEffect;
+            content: string;
+            style: string | false | import('vue').CSSProperties | import('vue').StyleValue[] | null;
+            enterable: boolean;
+            pure: boolean;
+            focusOnShow: boolean;
+            trapping: boolean;
+            popperClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+            popperStyle: string | false | import('vue').CSSProperties | import('vue').StyleValue[] | null;
+            stopPopperMouseEvent: boolean;
+            virtualTriggering: boolean;
+            loop: boolean;
+            boundariesPadding: number;
+            gpuAcceleration: boolean;
+            placement: import('element-plus').Placement;
+            popperOptions: Partial<import('element-plus').Options>;
+            strategy: "fixed" | "absolute";
+            arrowOffset: number;
+            showArrow: boolean;
+            role: "dialog" | "menu" | "tree" | "grid" | "group" | "listbox" | "navigation" | "tooltip";
+            showAfter: number;
+            hideAfter: number;
+            autoClose: number;
+            trigger: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').TooltipTriggerType>;
+            triggerKeys: string[];
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+            $slots: {
+                default?: (props: {}) => any;
+            } & {
+                content?: (props: {}) => any;
+            };
+        })>;
+        ElSwitch: import('element-plus/es/utils/vue/typescript.mjs').SFCWithInstall<{
+            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').SwitchProps> & Readonly<{
+                "onUpdate:modelValue"?: ((val: string | number | boolean) => any) | undefined;
+                onChange?: ((val: string | number | boolean) => any) | undefined;
+                onInput?: ((val: string | number | boolean) => any) | undefined;
+            }>, {
+                focus: () => void;
+                checked: import('vue').ComputedRef<boolean>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                "update:modelValue": (val: string | number | boolean) => void;
+                change: (val: string | number | boolean) => void;
+                input: (val: string | number | boolean) => void;
+            }, import('vue').PublicProps, {
+                width: string | number;
+                name: string;
+                modelValue: boolean | string | number;
+                disabled: boolean;
+                validateEvent: boolean;
+                activeText: string;
+                inactiveText: string;
+                activeValue: boolean | string | number;
+                inactiveValue: boolean | string | number;
+            }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import('element-plus').SwitchProps> & Readonly<{
+                "onUpdate:modelValue"?: ((val: string | number | boolean) => any) | undefined;
+                onChange?: ((val: string | number | boolean) => any) | undefined;
+                onInput?: ((val: string | number | boolean) => any) | undefined;
+            }>, {
+                focus: () => void;
+                checked: import('vue').ComputedRef<boolean>;
+            }, {}, {}, {}, {
+                width: string | number;
+                name: string;
+                modelValue: boolean | string | number;
+                disabled: boolean;
+                validateEvent: boolean;
+                activeText: string;
+                inactiveText: string;
+                activeValue: boolean | string | number;
+                inactiveValue: boolean | string | number;
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').SwitchProps> & Readonly<{
+            "onUpdate:modelValue"?: ((val: string | number | boolean) => any) | undefined;
+            onChange?: ((val: string | number | boolean) => any) | undefined;
+            onInput?: ((val: string | number | boolean) => any) | undefined;
+        }>, {
+            focus: () => void;
+            checked: import('vue').ComputedRef<boolean>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            "update:modelValue": (val: string | number | boolean) => void;
+            change: (val: string | number | boolean) => void;
+            input: (val: string | number | boolean) => void;
+        }, string, {
+            width: string | number;
+            name: string;
+            modelValue: boolean | string | number;
+            disabled: boolean;
+            validateEvent: boolean;
+            activeText: string;
+            inactiveText: string;
+            activeValue: boolean | string | number;
+            inactiveValue: boolean | string | number;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+            $slots: {
+                inactive?: (props: {}) => any;
+            } & {
+                inactive?: (props: {}) => any;
+            } & {
+                active?: (props: {}) => any;
+            } & {
+                "active-action"?: (props: {}) => any;
+            } & {
+                "inactive-action"?: (props: {}) => any;
+            } & {
+                active?: (props: {}) => any;
+            };
+        })>;
+        ElTag: import('element-plus/es/utils/vue/typescript.mjs').SFCWithInstall<{
+            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').TagProps> & Readonly<{
+                onClose?: ((evt: MouseEvent) => any) | undefined;
+                onClick?: ((evt: MouseEvent) => any) | undefined;
+            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                close: (evt: MouseEvent) => void;
+                click: (evt: MouseEvent) => void;
+            }, import('vue').PublicProps, {
+                type: "primary" | "success" | "info" | "warning" | "danger";
+                effect: "dark" | "light" | "plain";
+            }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import('element-plus').TagProps> & Readonly<{
+                onClose?: ((evt: MouseEvent) => any) | undefined;
+                onClick?: ((evt: MouseEvent) => any) | undefined;
+            }>, {}, {}, {}, {}, {
+                type: "primary" | "success" | "info" | "warning" | "danger";
+                effect: "dark" | "light" | "plain";
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').TagProps> & Readonly<{
+            onClose?: ((evt: MouseEvent) => any) | undefined;
+            onClick?: ((evt: MouseEvent) => any) | undefined;
+        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            close: (evt: MouseEvent) => void;
+            click: (evt: MouseEvent) => void;
+        }, string, {
+            type: "primary" | "success" | "info" | "warning" | "danger";
+            effect: "dark" | "light" | "plain";
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+            $slots: {
+                default?: (props: {}) => any;
+            } & {
+                default?: (props: {}) => any;
+            };
+        })>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    verify: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        appId: {
+            type: StringConstructor;
+            default: string;
+        };
+        resultTitle: {
+            type: StringConstructor;
+            default: string;
+        };
+        phone: {
+            type: StringConstructor;
+            default: () => string;
+        };
+        userId: {
+            type: StringConstructor;
+            default: () => string;
+        };
+    }>, {}, {
+        submitText: string;
+        sureText: string;
+        title: string;
+        isSuccess: boolean;
+        accessKey: string;
+        smsKey: string;
+        codeTime: any;
+        opreation: any;
+        content: any;
+        loading: boolean;
+    }, {}, {
+        getSmsKey(e: any): void;
+        close(): void;
+        cancel(): void;
+        submit(form: any, validForm: any, callback: any): void;
+        loginOut(): Promise<void>;
+        init(opreation: any): void;
+        viewAppAccessKey(form: any, callback: any): void;
+        resetAppAccessKey(form: any, callback: any): void;
+        viewAccessKey(form: any, callback: any): void;
+        resetAccessKey(form: any, callback: any): void;
+        resetPhone(form: any, callback: any): void;
+        handleCopy(): void;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        appId: {
+            type: StringConstructor;
+            default: string;
+        };
+        resultTitle: {
+            type: StringConstructor;
+            default: string;
+        };
+        phone: {
+            type: StringConstructor;
+            default: () => string;
+        };
+        userId: {
+            type: StringConstructor;
+            default: () => string;
+        };
+    }>> & Readonly<{}>, {
+        phone: string;
+        userId: string;
+        appId: string;
+        resultTitle: string;
+    }, {}, {
+        resetPassword: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            userId: {
+                type: StringConstructor;
+                default: () => string;
+            };
+        }>, {}, {
+            form: {
+                password: string;
+                repassword: string;
+                oldPassword: string;
+                confirmKey: string;
+            };
+            rules: {
+                oldPassword: {
+                    required: boolean;
+                    message: string;
+                    trigger: string;
+                }[];
+                password: {
+                    required: boolean;
+                    validator: Function;
+                    trigger: string;
+                }[];
+                repassword: {
+                    required: boolean;
+                    validator: Function;
+                    trigger: string;
+                }[];
+            };
+        }, {}, {
+            handleClose(): void;
+            setComfirmKey(key: string): void;
+            handleOk(callback: any): void;
+            loginOut(): Promise<void>;
+            checkPassword(rule: any, value: any, callback: any): void;
+            checkRepassword(rule: any, value: any, callback: any): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "cancel"[], "cancel", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            userId: {
+                type: StringConstructor;
+                default: () => string;
+            };
+        }>> & Readonly<{
+            onCancel?: ((...args: any[]) => any) | undefined;
+        }>, {
+            userId: string;
+        }, {}, {
+            ElForm: {
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').FormProps> & Readonly<{
+                    onValidate?: ((prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => any) | undefined;
+                }>, {
+                    validate: (callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+                    validateField: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>, callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+                    resetFields: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>) => void;
+                    clearValidate: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>) => void;
+                    scrollToField: (prop: import('element-plus').FormItemProp) => void;
+                    getField: (prop: import('element-plus').FormItemProp) => import('element-plus').FormItemContext | undefined;
+                    fields: import('vue').Reactive<import('element-plus').FormItemContext[]>;
+                    setInitialValues: (initModel: Record<string, any>) => void;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    validate: (prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => void;
+                }, import('vue').PublicProps, {
+                    labelWidth: string | number;
+                    labelPosition: "left" | "right" | "top";
+                    requireAsteriskPosition: "left" | "right";
+                    labelSuffix: string;
+                    showMessage: boolean;
+                    validateOnRuleChange: boolean;
+                    scrollIntoViewOptions: ScrollIntoViewOptions | boolean;
+                }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('element-plus').FormProps> & Readonly<{
+                    onValidate?: ((prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => any) | undefined;
+                }>, {
+                    validate: (callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+                    validateField: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>, callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+                    resetFields: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>) => void;
+                    clearValidate: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>) => void;
+                    scrollToField: (prop: import('element-plus').FormItemProp) => void;
+                    getField: (prop: import('element-plus').FormItemProp) => import('element-plus').FormItemContext | undefined;
+                    fields: import('vue').Reactive<import('element-plus').FormItemContext[]>;
+                    setInitialValues: (initModel: Record<string, any>) => void;
+                }, {}, {}, {}, {
+                    labelWidth: string | number;
+                    labelPosition: "left" | "right" | "top";
+                    requireAsteriskPosition: "left" | "right";
+                    labelSuffix: string;
+                    showMessage: boolean;
+                    validateOnRuleChange: boolean;
+                    scrollIntoViewOptions: ScrollIntoViewOptions | boolean;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').FormProps> & Readonly<{
+                onValidate?: ((prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => any) | undefined;
+            }>, {
+                validate: (callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+                validateField: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>, callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+                resetFields: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>) => void;
+                clearValidate: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>) => void;
+                scrollToField: (prop: import('element-plus').FormItemProp) => void;
+                getField: (prop: import('element-plus').FormItemProp) => import('element-plus').FormItemContext | undefined;
+                fields: import('vue').Reactive<import('element-plus').FormItemContext[]>;
+                setInitialValues: (initModel: Record<string, any>) => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                validate: (prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => void;
+            }, string, {
+                labelWidth: string | number;
+                labelPosition: "left" | "right" | "top";
+                requireAsteriskPosition: "left" | "right";
+                labelSuffix: string;
+                showMessage: boolean;
+                validateOnRuleChange: boolean;
+                scrollIntoViewOptions: ScrollIntoViewOptions | boolean;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    default?: (props: {}) => any;
+                };
+            }) & import('vue').ObjectPlugin & {
+                setPropsDefaults: (defaults: {
+                    readonly model?: (() => Record<string, any>) | undefined;
+                    readonly rules?: (() => Partial<Record<string, Record<string, any> | import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemRule>>>) | undefined;
+                    readonly labelPosition?: "top" | "right" | "left" | (() => "top" | "right" | "left") | undefined;
+                    readonly requireAsteriskPosition?: "right" | "left" | (() => "right" | "left") | undefined;
+                    readonly labelWidth?: string | number | (() => string | number) | undefined;
+                    readonly labelSuffix?: string | (() => string) | undefined;
+                    readonly inline?: boolean | (() => boolean) | undefined;
+                    readonly inlineMessage?: boolean | (() => boolean) | undefined;
+                    readonly statusIcon?: boolean | (() => boolean) | undefined;
+                    readonly showMessage?: boolean | (() => boolean) | undefined;
+                    readonly validateOnRuleChange?: boolean | (() => boolean) | undefined;
+                    readonly hideRequiredAsterisk?: boolean | (() => boolean) | undefined;
+                    readonly scrollToError?: boolean | (() => boolean) | undefined;
+                    readonly scrollIntoViewOptions?: boolean | (() => boolean | ScrollIntoViewOptions) | undefined;
+                    readonly size?: "" | "default" | "small" | "large" | (() => "" | "default" | "small" | "large") | undefined;
+                    readonly disabled?: boolean | (() => boolean) | undefined;
+                }) => void;
+            } & {
+                FormItem: {
+                    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').FormItemProps> & Readonly<{}>, {
+                        size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                        validateMessage: import('vue').Ref<string, string>;
+                        validateState: import('vue').Ref<"" | "success" | "error" | "validating", "" | "success" | "error" | "validating">;
+                        validate: (trigger: string, callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+                        clearValidate: () => void;
+                        resetField: () => void;
+                        setInitialValue: (value: any) => void;
+                    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+                        required: boolean;
+                        labelPosition: "left" | "right" | "top" | "";
+                        inlineMessage: boolean;
+                        showMessage: boolean;
+                    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                        P: {};
+                        B: {};
+                        D: {};
+                        C: {};
+                        M: {};
+                        Defaults: {};
+                    }, Readonly<import('element-plus').FormItemProps> & Readonly<{}>, {
+                        size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                        validateMessage: import('vue').Ref<string, string>;
+                        validateState: import('vue').Ref<"" | "success" | "error" | "validating", "" | "success" | "error" | "validating">;
+                        validate: (trigger: string, callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+                        clearValidate: () => void;
+                        resetField: () => void;
+                        setInitialValue: (value: any) => void;
+                    }, {}, {}, {}, {
+                        required: boolean;
+                        labelPosition: "left" | "right" | "top" | "";
+                        inlineMessage: boolean;
+                        showMessage: boolean;
+                    }>;
+                    __isFragment?: never;
+                    __isTeleport?: never;
+                    __isSuspense?: never;
+                } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').FormItemProps> & Readonly<{}>, {
+                    size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                    validateMessage: import('vue').Ref<string, string>;
+                    validateState: import('vue').Ref<"" | "success" | "error" | "validating", "" | "success" | "error" | "validating">;
+                    validate: (trigger: string, callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+                    clearValidate: () => void;
+                    resetField: () => void;
+                    setInitialValue: (value: any) => void;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                    required: boolean;
+                    labelPosition: "left" | "right" | "top" | "";
+                    inlineMessage: boolean;
+                    showMessage: boolean;
+                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                    $slots: {
+                        label?: (props: {
+                            label: string;
+                        }) => any;
+                    } & {
+                        default?: (props: {}) => any;
+                    } & {
+                        error?: (props: {
+                            error: string;
+                        }) => any;
+                    };
+                });
+            };
+            ElFormItem: import('element-plus/es/utils/vue/typescript.mjs').SFCWithInstall<{
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').FormItemProps> & Readonly<{}>, {
+                    size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                    validateMessage: import('vue').Ref<string, string>;
+                    validateState: import('vue').Ref<"" | "success" | "error" | "validating", "" | "success" | "error" | "validating">;
+                    validate: (trigger: string, callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+                    clearValidate: () => void;
+                    resetField: () => void;
+                    setInitialValue: (value: any) => void;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+                    required: boolean;
+                    labelPosition: "left" | "right" | "top" | "";
+                    inlineMessage: boolean;
+                    showMessage: boolean;
+                }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('element-plus').FormItemProps> & Readonly<{}>, {
+                    size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                    validateMessage: import('vue').Ref<string, string>;
+                    validateState: import('vue').Ref<"" | "success" | "error" | "validating", "" | "success" | "error" | "validating">;
+                    validate: (trigger: string, callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+                    clearValidate: () => void;
+                    resetField: () => void;
+                    setInitialValue: (value: any) => void;
+                }, {}, {}, {}, {
+                    required: boolean;
+                    labelPosition: "left" | "right" | "top" | "";
+                    inlineMessage: boolean;
+                    showMessage: boolean;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').FormItemProps> & Readonly<{}>, {
+                size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                validateMessage: import('vue').Ref<string, string>;
+                validateState: import('vue').Ref<"" | "success" | "error" | "validating", "" | "success" | "error" | "validating">;
+                validate: (trigger: string, callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+                clearValidate: () => void;
+                resetField: () => void;
+                setInitialValue: (value: any) => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                required: boolean;
+                labelPosition: "left" | "right" | "top" | "";
+                inlineMessage: boolean;
+                showMessage: boolean;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    label?: (props: {
+                        label: string;
+                    }) => any;
+                } & {
+                    default?: (props: {}) => any;
+                } & {
+                    error?: (props: {
+                        error: string;
+                    }) => any;
+                };
+            })>;
+            ElInput: import('element-plus/es/utils/vue/typescript.mjs').SFCWithInstall<{
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').InputProps> & Readonly<{
+                    onClear?: ((evt: MouseEvent | undefined) => any) | undefined;
+                    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                    onChange?: ((value: string, evt?: Event | undefined) => any) | undefined;
+                    onInput?: ((value: string) => any) | undefined;
+                    onFocus?: ((evt: FocusEvent) => any) | undefined;
+                    onBlur?: ((evt: FocusEvent) => any) | undefined;
+                    onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+                    onMouseenter?: ((evt: MouseEvent) => any) | undefined;
+                    onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;
+                    onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;
+                    onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;
+                    onCompositionend?: ((evt: CompositionEvent) => any) | undefined;
+                }>, {
+                    input: import('vue').ShallowRef<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+                    textarea: import('vue').ShallowRef<HTMLTextAreaElement | undefined, HTMLTextAreaElement | undefined>;
+                    ref: import('vue').ComputedRef<HTMLInputElement | HTMLTextAreaElement | undefined>;
+                    textareaStyle: import('vue').ComputedRef<import('vue').StyleValue>;
+                    autosize: import('vue').Ref<import('element-plus').InputAutoSize | undefined, import('element-plus').InputAutoSize | undefined>;
+                    isComposing: import('vue').Ref<boolean, boolean>;
+                    passwordVisible: import('vue').Ref<boolean, boolean>;
+                    focus: () => void | undefined;
+                    blur: () => void | undefined;
+                    select: () => void;
+                    clear: (evt?: MouseEvent) => void;
+                    resizeTextarea: () => void;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    clear: (evt: MouseEvent | undefined) => void;
+                    "update:modelValue": (value: string) => void;
+                    change: (value: string, evt?: Event | undefined) => void;
+                    input: (value: string) => void;
+                    focus: (evt: FocusEvent) => void;
+                    blur: (evt: FocusEvent) => void;
+                    mouseleave: (evt: MouseEvent) => void;
+                    mouseenter: (evt: MouseEvent) => void;
+                    keydown: (evt: Event | KeyboardEvent) => void;
+                    compositionstart: (evt: CompositionEvent) => void;
+                    compositionupdate: (evt: CompositionEvent) => void;
+                    compositionend: (evt: CompositionEvent) => void;
+                }, import('vue').PublicProps, {
+                    type: import('element-plus').InputType;
+                    modelValue: string | number | null;
+                    disabled: boolean;
+                    modelModifiers: import('element-plus').InputModelModifiers;
+                    autocomplete: string;
+                    clearIcon: import('element-plus/es/utils/vue/icon.mjs').IconPropType;
+                    wordLimitPosition: "inside" | "outside";
+                    tabindex: string | number;
+                    validateEvent: boolean;
+                    inputStyle: string | false | import('vue').CSSProperties | import('vue').StyleValue[] | null;
+                    rows: number;
+                }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('element-plus').InputProps> & Readonly<{
+                    onClear?: ((evt: MouseEvent | undefined) => any) | undefined;
+                    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                    onChange?: ((value: string, evt?: Event | undefined) => any) | undefined;
+                    onInput?: ((value: string) => any) | undefined;
+                    onFocus?: ((evt: FocusEvent) => any) | undefined;
+                    onBlur?: ((evt: FocusEvent) => any) | undefined;
+                    onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+                    onMouseenter?: ((evt: MouseEvent) => any) | undefined;
+                    onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;
+                    onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;
+                    onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;
+                    onCompositionend?: ((evt: CompositionEvent) => any) | undefined;
+                }>, {
+                    input: import('vue').ShallowRef<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+                    textarea: import('vue').ShallowRef<HTMLTextAreaElement | undefined, HTMLTextAreaElement | undefined>;
+                    ref: import('vue').ComputedRef<HTMLInputElement | HTMLTextAreaElement | undefined>;
+                    textareaStyle: import('vue').ComputedRef<import('vue').StyleValue>;
+                    autosize: import('vue').Ref<import('element-plus').InputAutoSize | undefined, import('element-plus').InputAutoSize | undefined>;
+                    isComposing: import('vue').Ref<boolean, boolean>;
+                    passwordVisible: import('vue').Ref<boolean, boolean>;
+                    focus: () => void | undefined;
+                    blur: () => void | undefined;
+                    select: () => void;
+                    clear: (evt?: MouseEvent) => void;
+                    resizeTextarea: () => void;
+                }, {}, {}, {}, {
+                    type: import('element-plus').InputType;
+                    modelValue: string | number | null;
+                    disabled: boolean;
+                    modelModifiers: import('element-plus').InputModelModifiers;
+                    autocomplete: string;
+                    clearIcon: import('element-plus/es/utils/vue/icon.mjs').IconPropType;
+                    wordLimitPosition: "inside" | "outside";
+                    tabindex: string | number;
+                    validateEvent: boolean;
+                    inputStyle: string | false | import('vue').CSSProperties | import('vue').StyleValue[] | null;
+                    rows: number;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').InputProps> & Readonly<{
+                onClear?: ((evt: MouseEvent | undefined) => any) | undefined;
+                "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                onChange?: ((value: string, evt?: Event | undefined) => any) | undefined;
+                onInput?: ((value: string) => any) | undefined;
+                onFocus?: ((evt: FocusEvent) => any) | undefined;
+                onBlur?: ((evt: FocusEvent) => any) | undefined;
+                onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+                onMouseenter?: ((evt: MouseEvent) => any) | undefined;
+                onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;
+                onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;
+                onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;
+                onCompositionend?: ((evt: CompositionEvent) => any) | undefined;
+            }>, {
+                input: import('vue').ShallowRef<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+                textarea: import('vue').ShallowRef<HTMLTextAreaElement | undefined, HTMLTextAreaElement | undefined>;
+                ref: import('vue').ComputedRef<HTMLInputElement | HTMLTextAreaElement | undefined>;
+                textareaStyle: import('vue').ComputedRef<import('vue').StyleValue>;
+                autosize: import('vue').Ref<import('element-plus').InputAutoSize | undefined, import('element-plus').InputAutoSize | undefined>;
+                isComposing: import('vue').Ref<boolean, boolean>;
+                passwordVisible: import('vue').Ref<boolean, boolean>;
+                focus: () => void | undefined;
+                blur: () => void | undefined;
+                select: () => void;
+                clear: (evt?: MouseEvent) => void;
+                resizeTextarea: () => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                clear: (evt: MouseEvent | undefined) => void;
+                "update:modelValue": (value: string) => void;
+                change: (value: string, evt?: Event | undefined) => void;
+                input: (value: string) => void;
+                focus: (evt: FocusEvent) => void;
+                blur: (evt: FocusEvent) => void;
+                mouseleave: (evt: MouseEvent) => void;
+                mouseenter: (evt: MouseEvent) => void;
+                keydown: (evt: Event | KeyboardEvent) => void;
+                compositionstart: (evt: CompositionEvent) => void;
+                compositionupdate: (evt: CompositionEvent) => void;
+                compositionend: (evt: CompositionEvent) => void;
+            }, string, {
+                type: import('element-plus').InputType;
+                modelValue: string | number | null;
+                disabled: boolean;
+                modelModifiers: import('element-plus').InputModelModifiers;
+                autocomplete: string;
+                clearIcon: import('element-plus/es/utils/vue/icon.mjs').IconPropType;
+                wordLimitPosition: "inside" | "outside";
+                tabindex: string | number;
+                validateEvent: boolean;
+                inputStyle: string | false | import('vue').CSSProperties | import('vue').StyleValue[] | null;
+                rows: number;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    prepend?: (props: {}) => any;
+                } & {
+                    prefix?: (props: {}) => any;
+                } & {
+                    suffix?: (props: {}) => any;
+                } & {
+                    'password-icon'?: (props: {
+                        visible: boolean;
+                    }) => any;
+                } & {
+                    append?: (props: {}) => any;
+                };
+            })>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        formDialog: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            phone: {
+                type: StringConstructor;
+                default: () => string;
+            };
+            title: {
+                type: StringConstructor;
+                default: () => string;
+            };
+            submitText: {
+                type: StringConstructor;
+                default: () => string;
+            };
+            isSuccess: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            sureText: {
+                type: StringConstructor;
+                default: () => string;
+            };
+            content: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {}, {
+            dialogVisible: boolean;
+            loading: boolean;
+            isSend: boolean;
+            codeTime: any;
+            codeTimer: any;
+            disabled: boolean;
+            form: Record<string, any>;
+            rules: {
+                phoneNumber: {
+                    required: boolean;
+                    validator: Function;
+                    trigger: string;
+                }[];
+                smsCode: {
+                    required: boolean;
+                    validator: Function;
+                    trigger: string;
+                }[];
+            };
+        }, {}, {
+            close(): void;
+            handleClose(): void;
+            cancelForm(): void;
+            submit(): void;
+            init(): void;
+            formInit(data?: any): void;
+            handleGetSmsCode(): void;
+            sendSmsCode(phone: string): void;
+            countDown(): void;
+            checkMobilePhone(rule: any, value: any, callback: any): void;
+            checkVerifyCode(rule: any, value: any, callback: any): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("submit" | "cancel" | "smsKey")[], "submit" | "cancel" | "smsKey", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            phone: {
+                type: StringConstructor;
+                default: () => string;
+            };
+            title: {
+                type: StringConstructor;
+                default: () => string;
+            };
+            submitText: {
+                type: StringConstructor;
+                default: () => string;
+            };
+            isSuccess: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            sureText: {
+                type: StringConstructor;
+                default: () => string;
+            };
+            content: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{
+            onSubmit?: ((...args: any[]) => any) | undefined;
+            onCancel?: ((...args: any[]) => any) | undefined;
+            onSmsKey?: ((...args: any[]) => any) | undefined;
+        }>, {
+            title: string;
+            submitText: string;
+            sureText: string;
+            phone: string;
+            content: string;
+            isSuccess: boolean;
+        }, {}, {
+            ElButton: {
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').ButtonProps> & Readonly<{
+                    onClick?: ((evt: MouseEvent) => any) | undefined;
+                }>, {
+                    ref: import('vue').Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+                    size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                    type: import('vue').ComputedRef<"" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
+                    disabled: import('vue').ComputedRef<boolean>;
+                    shouldAddSpace: import('vue').ComputedRef<boolean>;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    click: (evt: MouseEvent) => void;
+                }, import('vue').PublicProps, {
+                    type: import('element-plus').ButtonType;
+                    text: boolean;
+                    disabled: boolean;
+                    round: boolean;
+                    dashed: boolean;
+                    nativeType: import('element-plus').ButtonNativeType;
+                    loadingIcon: import('element-plus/es/utils/vue/icon.mjs').IconPropType;
+                    plain: boolean;
+                    autoInsertSpace: boolean;
+                    tag: string | import('vue').Component;
+                }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('element-plus').ButtonProps> & Readonly<{
+                    onClick?: ((evt: MouseEvent) => any) | undefined;
+                }>, {
+                    ref: import('vue').Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+                    size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                    type: import('vue').ComputedRef<"" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
+                    disabled: import('vue').ComputedRef<boolean>;
+                    shouldAddSpace: import('vue').ComputedRef<boolean>;
+                }, {}, {}, {}, {
+                    type: import('element-plus').ButtonType;
+                    text: boolean;
+                    disabled: boolean;
+                    round: boolean;
+                    dashed: boolean;
+                    nativeType: import('element-plus').ButtonNativeType;
+                    loadingIcon: import('element-plus/es/utils/vue/icon.mjs').IconPropType;
+                    plain: boolean;
+                    autoInsertSpace: boolean;
+                    tag: string | import('vue').Component;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').ButtonProps> & Readonly<{
+                onClick?: ((evt: MouseEvent) => any) | undefined;
+            }>, {
+                ref: import('vue').Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+                size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                type: import('vue').ComputedRef<"" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
+                disabled: import('vue').ComputedRef<boolean>;
+                shouldAddSpace: import('vue').ComputedRef<boolean>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                click: (evt: MouseEvent) => void;
+            }, string, {
+                type: import('element-plus').ButtonType;
+                text: boolean;
+                disabled: boolean;
+                round: boolean;
+                dashed: boolean;
+                nativeType: import('element-plus').ButtonNativeType;
+                loadingIcon: import('element-plus/es/utils/vue/icon.mjs').IconPropType;
+                plain: boolean;
+                autoInsertSpace: boolean;
+                tag: string | import('vue').Component;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    loading?: (props: {}) => any;
+                } & {
+                    icon?: (props: {}) => any;
+                } & {
+                    default?: (props: {}) => any;
+                };
+            }) & import('vue').ObjectPlugin & {
+                setPropsDefaults: (defaults: {
+                    readonly size?: "" | "default" | "small" | "large" | (() => "" | "default" | "small" | "large") | undefined;
+                    readonly disabled?: boolean | (() => boolean) | undefined;
+                    readonly type?: "" | "default" | "primary" | "success" | "warning" | "info" | "text" | "danger" | (() => "" | "default" | "primary" | "success" | "warning" | "info" | "text" | "danger") | undefined;
+                    readonly icon?: string | import('vue').FunctionalComponent<any, {}, any, {}> | {
+                        new (...args: any[]): any;
+                        __isFragment?: never;
+                        __isTeleport?: never;
+                        __isSuspense?: never;
+                    } | (() => (import('element-plus/es/utils/vue/icon.mjs').IconPropType | undefined) & {}) | undefined;
+                    readonly nativeType?: "button" | "submit" | "reset" | (() => "button" | "submit" | "reset") | undefined;
+                    readonly loading?: boolean | (() => boolean) | undefined;
+                    readonly loadingIcon?: string | import('vue').FunctionalComponent<any, {}, any, {}> | {
+                        new (...args: any[]): any;
+                        __isFragment?: never;
+                        __isTeleport?: never;
+                        __isSuspense?: never;
+                    } | (() => (import('element-plus/es/utils/vue/icon.mjs').IconPropType | undefined) & {}) | undefined;
+                    readonly plain?: boolean | (() => boolean) | undefined;
+                    readonly text?: boolean | (() => boolean) | undefined;
+                    readonly link?: boolean | (() => boolean) | undefined;
+                    readonly bg?: boolean | (() => boolean) | undefined;
+                    readonly autofocus?: boolean | (() => boolean) | undefined;
+                    readonly round?: boolean | (() => boolean) | undefined;
+                    readonly circle?: boolean | (() => boolean) | undefined;
+                    readonly dashed?: boolean | (() => boolean) | undefined;
+                    readonly color?: string | (() => string) | undefined;
+                    readonly dark?: boolean | (() => boolean) | undefined;
+                    readonly autoInsertSpace?: boolean | (() => boolean) | undefined;
+                    readonly tag?: string | import('vue').FunctionalComponent<any, {}, any, {}> | {
+                        new (...args: any[]): any;
+                        __isFragment?: never;
+                        __isTeleport?: never;
+                        __isSuspense?: never;
+                    } | (() => (string | import('vue').Component | undefined) & {}) | undefined;
+                }) => void;
+            } & {
+                ButtonGroup: {
+                    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus/es/components/button/src/button-group.mjs').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+                        direction: "horizontal" | "vertical";
+                        type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
+                    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                        P: {};
+                        B: {};
+                        D: {};
+                        C: {};
+                        M: {};
+                        Defaults: {};
+                    }, Readonly<import('element-plus/es/components/button/src/button-group.mjs').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, {
+                        direction: "horizontal" | "vertical";
+                        type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
+                    }>;
+                    __isFragment?: never;
+                    __isTeleport?: never;
+                    __isSuspense?: never;
+                } & import('vue').ComponentOptionsBase<Readonly<import('element-plus/es/components/button/src/button-group.mjs').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                    direction: "horizontal" | "vertical";
+                    type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
+                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                    $slots: {
+                        default?: (props: {}) => any;
+                    };
+                });
+            };
+            ElButtonGroup: import('element-plus/es/utils/vue/typescript.mjs').SFCWithInstall<{
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus/es/components/button/src/button-group.mjs').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+                    direction: "horizontal" | "vertical";
+                    type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
+                }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('element-plus/es/components/button/src/button-group.mjs').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, {
+                    direction: "horizontal" | "vertical";
+                    type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('element-plus/es/components/button/src/button-group.mjs').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                direction: "horizontal" | "vertical";
+                type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    default?: (props: {}) => any;
+                };
+            })>;
+            ElDialog: import('element-plus/es/utils/vue/typescript.mjs').SFCWithInstall<{
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').DialogProps> & Readonly<{
+                    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                    onOpen?: (() => any) | undefined;
+                    onOpened?: (() => any) | undefined;
+                    onClose?: (() => any) | undefined;
+                    onClosed?: (() => any) | undefined;
+                    onOpenAutoFocus?: (() => any) | undefined;
+                    onCloseAutoFocus?: (() => any) | undefined;
+                }>, {
+                    visible: import('vue').Ref<boolean, boolean>;
+                    dialogContentRef: import('vue').Ref<any, any>;
+                    resetPosition: () => void;
+                    handleClose: () => void;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    "update:modelValue": (value: boolean) => void;
+                    open: () => void;
+                    opened: () => void;
+                    close: () => void;
+                    closed: () => void;
+                    openAutoFocus: () => void;
+                    closeAutoFocus: () => void;
+                }, import('vue').PublicProps, {
+                    title: string;
+                    appendTo: string | HTMLElement;
+                    closeOnClickModal: boolean;
+                    closeOnPressEscape: boolean;
+                    lockScroll: boolean;
+                    modal: boolean;
+                    openDelay: number;
+                    closeDelay: number;
+                    modalClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                    headerAriaLevel: string;
+                    transition: import('element-plus').DialogTransition;
+                    alignCenter: boolean;
+                    draggable: boolean;
+                    overflow: boolean;
+                    headerClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                    bodyClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                    footerClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                    showClose: boolean;
+                    ariaLevel: string;
+                }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('element-plus').DialogProps> & Readonly<{
+                    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                    onOpen?: (() => any) | undefined;
+                    onOpened?: (() => any) | undefined;
+                    onClose?: (() => any) | undefined;
+                    onClosed?: (() => any) | undefined;
+                    onOpenAutoFocus?: (() => any) | undefined;
+                    onCloseAutoFocus?: (() => any) | undefined;
+                }>, {
+                    visible: import('vue').Ref<boolean, boolean>;
+                    dialogContentRef: import('vue').Ref<any, any>;
+                    resetPosition: () => void;
+                    handleClose: () => void;
+                }, {}, {}, {}, {
+                    title: string;
+                    appendTo: string | HTMLElement;
+                    closeOnClickModal: boolean;
+                    closeOnPressEscape: boolean;
+                    lockScroll: boolean;
+                    modal: boolean;
+                    openDelay: number;
+                    closeDelay: number;
+                    modalClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                    headerAriaLevel: string;
+                    transition: import('element-plus').DialogTransition;
+                    alignCenter: boolean;
+                    draggable: boolean;
+                    overflow: boolean;
+                    headerClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                    bodyClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                    footerClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                    showClose: boolean;
+                    ariaLevel: string;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').DialogProps> & Readonly<{
+                "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                onOpen?: (() => any) | undefined;
+                onOpened?: (() => any) | undefined;
+                onClose?: (() => any) | undefined;
+                onClosed?: (() => any) | undefined;
+                onOpenAutoFocus?: (() => any) | undefined;
+                onCloseAutoFocus?: (() => any) | undefined;
+            }>, {
+                visible: import('vue').Ref<boolean, boolean>;
+                dialogContentRef: import('vue').Ref<any, any>;
+                resetPosition: () => void;
+                handleClose: () => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                "update:modelValue": (value: boolean) => void;
+                open: () => void;
+                opened: () => void;
+                close: () => void;
+                closed: () => void;
+                openAutoFocus: () => void;
+                closeAutoFocus: () => void;
+            }, string, {
+                title: string;
+                appendTo: string | HTMLElement;
+                closeOnClickModal: boolean;
+                closeOnPressEscape: boolean;
+                lockScroll: boolean;
+                modal: boolean;
+                openDelay: number;
+                closeDelay: number;
+                modalClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                headerAriaLevel: string;
+                transition: import('element-plus').DialogTransition;
+                alignCenter: boolean;
+                draggable: boolean;
+                overflow: boolean;
+                headerClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                bodyClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                footerClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                showClose: boolean;
+                ariaLevel: string;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    header?: (props: {
+                        close: () => void;
+                        titleId: string;
+                        titleClass: string;
+                    }) => any;
+                } & {
+                    title?: (props: {}) => any;
+                } & {
+                    default?: (props: {}) => any;
+                } & {
+                    footer?: (props: {}) => any;
+                };
+            })>;
+            ElForm: {
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').FormProps> & Readonly<{
+                    onValidate?: ((prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => any) | undefined;
+                }>, {
+                    validate: (callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+                    validateField: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>, callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+                    resetFields: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>) => void;
+                    clearValidate: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>) => void;
+                    scrollToField: (prop: import('element-plus').FormItemProp) => void;
+                    getField: (prop: import('element-plus').FormItemProp) => import('element-plus').FormItemContext | undefined;
+                    fields: import('vue').Reactive<import('element-plus').FormItemContext[]>;
+                    setInitialValues: (initModel: Record<string, any>) => void;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    validate: (prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => void;
+                }, import('vue').PublicProps, {
+                    labelWidth: string | number;
+                    labelPosition: "left" | "right" | "top";
+                    requireAsteriskPosition: "left" | "right";
+                    labelSuffix: string;
+                    showMessage: boolean;
+                    validateOnRuleChange: boolean;
+                    scrollIntoViewOptions: ScrollIntoViewOptions | boolean;
+                }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('element-plus').FormProps> & Readonly<{
+                    onValidate?: ((prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => any) | undefined;
+                }>, {
+                    validate: (callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+                    validateField: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>, callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+                    resetFields: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>) => void;
+                    clearValidate: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>) => void;
+                    scrollToField: (prop: import('element-plus').FormItemProp) => void;
+                    getField: (prop: import('element-plus').FormItemProp) => import('element-plus').FormItemContext | undefined;
+                    fields: import('vue').Reactive<import('element-plus').FormItemContext[]>;
+                    setInitialValues: (initModel: Record<string, any>) => void;
+                }, {}, {}, {}, {
+                    labelWidth: string | number;
+                    labelPosition: "left" | "right" | "top";
+                    requireAsteriskPosition: "left" | "right";
+                    labelSuffix: string;
+                    showMessage: boolean;
+                    validateOnRuleChange: boolean;
+                    scrollIntoViewOptions: ScrollIntoViewOptions | boolean;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').FormProps> & Readonly<{
+                onValidate?: ((prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => any) | undefined;
+            }>, {
+                validate: (callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+                validateField: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>, callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+                resetFields: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>) => void;
+                clearValidate: (props?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemProp>) => void;
+                scrollToField: (prop: import('element-plus').FormItemProp) => void;
+                getField: (prop: import('element-plus').FormItemProp) => import('element-plus').FormItemContext | undefined;
+                fields: import('vue').Reactive<import('element-plus').FormItemContext[]>;
+                setInitialValues: (initModel: Record<string, any>) => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                validate: (prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => void;
+            }, string, {
+                labelWidth: string | number;
+                labelPosition: "left" | "right" | "top";
+                requireAsteriskPosition: "left" | "right";
+                labelSuffix: string;
+                showMessage: boolean;
+                validateOnRuleChange: boolean;
+                scrollIntoViewOptions: ScrollIntoViewOptions | boolean;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    default?: (props: {}) => any;
+                };
+            }) & import('vue').ObjectPlugin & {
+                setPropsDefaults: (defaults: {
+                    readonly model?: (() => Record<string, any>) | undefined;
+                    readonly rules?: (() => Partial<Record<string, Record<string, any> | import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemRule>>>) | undefined;
+                    readonly labelPosition?: "top" | "right" | "left" | (() => "top" | "right" | "left") | undefined;
+                    readonly requireAsteriskPosition?: "right" | "left" | (() => "right" | "left") | undefined;
+                    readonly labelWidth?: string | number | (() => string | number) | undefined;
+                    readonly labelSuffix?: string | (() => string) | undefined;
+                    readonly inline?: boolean | (() => boolean) | undefined;
+                    readonly inlineMessage?: boolean | (() => boolean) | undefined;
+                    readonly statusIcon?: boolean | (() => boolean) | undefined;
+                    readonly showMessage?: boolean | (() => boolean) | undefined;
+                    readonly validateOnRuleChange?: boolean | (() => boolean) | undefined;
+                    readonly hideRequiredAsterisk?: boolean | (() => boolean) | undefined;
+                    readonly scrollToError?: boolean | (() => boolean) | undefined;
+                    readonly scrollIntoViewOptions?: boolean | (() => boolean | ScrollIntoViewOptions) | undefined;
+                    readonly size?: "" | "default" | "small" | "large" | (() => "" | "default" | "small" | "large") | undefined;
+                    readonly disabled?: boolean | (() => boolean) | undefined;
+                }) => void;
+            } & {
+                FormItem: {
+                    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').FormItemProps> & Readonly<{}>, {
+                        size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                        validateMessage: import('vue').Ref<string, string>;
+                        validateState: import('vue').Ref<"" | "success" | "error" | "validating", "" | "success" | "error" | "validating">;
+                        validate: (trigger: string, callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+                        clearValidate: () => void;
+                        resetField: () => void;
+                        setInitialValue: (value: any) => void;
+                    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+                        required: boolean;
+                        labelPosition: "left" | "right" | "top" | "";
+                        inlineMessage: boolean;
+                        showMessage: boolean;
+                    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                        P: {};
+                        B: {};
+                        D: {};
+                        C: {};
+                        M: {};
+                        Defaults: {};
+                    }, Readonly<import('element-plus').FormItemProps> & Readonly<{}>, {
+                        size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                        validateMessage: import('vue').Ref<string, string>;
+                        validateState: import('vue').Ref<"" | "success" | "error" | "validating", "" | "success" | "error" | "validating">;
+                        validate: (trigger: string, callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+                        clearValidate: () => void;
+                        resetField: () => void;
+                        setInitialValue: (value: any) => void;
+                    }, {}, {}, {}, {
+                        required: boolean;
+                        labelPosition: "left" | "right" | "top" | "";
+                        inlineMessage: boolean;
+                        showMessage: boolean;
+                    }>;
+                    __isFragment?: never;
+                    __isTeleport?: never;
+                    __isSuspense?: never;
+                } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').FormItemProps> & Readonly<{}>, {
+                    size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                    validateMessage: import('vue').Ref<string, string>;
+                    validateState: import('vue').Ref<"" | "success" | "error" | "validating", "" | "success" | "error" | "validating">;
+                    validate: (trigger: string, callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+                    clearValidate: () => void;
+                    resetField: () => void;
+                    setInitialValue: (value: any) => void;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                    required: boolean;
+                    labelPosition: "left" | "right" | "top" | "";
+                    inlineMessage: boolean;
+                    showMessage: boolean;
+                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                    $slots: {
+                        label?: (props: {
+                            label: string;
+                        }) => any;
+                    } & {
+                        default?: (props: {}) => any;
+                    } & {
+                        error?: (props: {
+                            error: string;
+                        }) => any;
+                    };
+                });
+            };
+            ElFormItem: import('element-plus/es/utils/vue/typescript.mjs').SFCWithInstall<{
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').FormItemProps> & Readonly<{}>, {
+                    size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                    validateMessage: import('vue').Ref<string, string>;
+                    validateState: import('vue').Ref<"" | "success" | "error" | "validating", "" | "success" | "error" | "validating">;
+                    validate: (trigger: string, callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+                    clearValidate: () => void;
+                    resetField: () => void;
+                    setInitialValue: (value: any) => void;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+                    required: boolean;
+                    labelPosition: "left" | "right" | "top" | "";
+                    inlineMessage: boolean;
+                    showMessage: boolean;
+                }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('element-plus').FormItemProps> & Readonly<{}>, {
+                    size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                    validateMessage: import('vue').Ref<string, string>;
+                    validateState: import('vue').Ref<"" | "success" | "error" | "validating", "" | "success" | "error" | "validating">;
+                    validate: (trigger: string, callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+                    clearValidate: () => void;
+                    resetField: () => void;
+                    setInitialValue: (value: any) => void;
+                }, {}, {}, {}, {
+                    required: boolean;
+                    labelPosition: "left" | "right" | "top" | "";
+                    inlineMessage: boolean;
+                    showMessage: boolean;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').FormItemProps> & Readonly<{}>, {
+                size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                validateMessage: import('vue').Ref<string, string>;
+                validateState: import('vue').Ref<"" | "success" | "error" | "validating", "" | "success" | "error" | "validating">;
+                validate: (trigger: string, callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+                clearValidate: () => void;
+                resetField: () => void;
+                setInitialValue: (value: any) => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                required: boolean;
+                labelPosition: "left" | "right" | "top" | "";
+                inlineMessage: boolean;
+                showMessage: boolean;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    label?: (props: {
+                        label: string;
+                    }) => any;
+                } & {
+                    default?: (props: {}) => any;
+                } & {
+                    error?: (props: {
+                        error: string;
+                    }) => any;
+                };
+            })>;
+            ElInput: import('element-plus/es/utils/vue/typescript.mjs').SFCWithInstall<{
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').InputProps> & Readonly<{
+                    onClear?: ((evt: MouseEvent | undefined) => any) | undefined;
+                    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                    onChange?: ((value: string, evt?: Event | undefined) => any) | undefined;
+                    onInput?: ((value: string) => any) | undefined;
+                    onFocus?: ((evt: FocusEvent) => any) | undefined;
+                    onBlur?: ((evt: FocusEvent) => any) | undefined;
+                    onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+                    onMouseenter?: ((evt: MouseEvent) => any) | undefined;
+                    onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;
+                    onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;
+                    onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;
+                    onCompositionend?: ((evt: CompositionEvent) => any) | undefined;
+                }>, {
+                    input: import('vue').ShallowRef<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+                    textarea: import('vue').ShallowRef<HTMLTextAreaElement | undefined, HTMLTextAreaElement | undefined>;
+                    ref: import('vue').ComputedRef<HTMLInputElement | HTMLTextAreaElement | undefined>;
+                    textareaStyle: import('vue').ComputedRef<import('vue').StyleValue>;
+                    autosize: import('vue').Ref<import('element-plus').InputAutoSize | undefined, import('element-plus').InputAutoSize | undefined>;
+                    isComposing: import('vue').Ref<boolean, boolean>;
+                    passwordVisible: import('vue').Ref<boolean, boolean>;
+                    focus: () => void | undefined;
+                    blur: () => void | undefined;
+                    select: () => void;
+                    clear: (evt?: MouseEvent) => void;
+                    resizeTextarea: () => void;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    clear: (evt: MouseEvent | undefined) => void;
+                    "update:modelValue": (value: string) => void;
+                    change: (value: string, evt?: Event | undefined) => void;
+                    input: (value: string) => void;
+                    focus: (evt: FocusEvent) => void;
+                    blur: (evt: FocusEvent) => void;
+                    mouseleave: (evt: MouseEvent) => void;
+                    mouseenter: (evt: MouseEvent) => void;
+                    keydown: (evt: Event | KeyboardEvent) => void;
+                    compositionstart: (evt: CompositionEvent) => void;
+                    compositionupdate: (evt: CompositionEvent) => void;
+                    compositionend: (evt: CompositionEvent) => void;
+                }, import('vue').PublicProps, {
+                    type: import('element-plus').InputType;
+                    modelValue: string | number | null;
+                    disabled: boolean;
+                    modelModifiers: import('element-plus').InputModelModifiers;
+                    autocomplete: string;
+                    clearIcon: import('element-plus/es/utils/vue/icon.mjs').IconPropType;
+                    wordLimitPosition: "inside" | "outside";
+                    tabindex: string | number;
+                    validateEvent: boolean;
+                    inputStyle: string | false | import('vue').CSSProperties | import('vue').StyleValue[] | null;
+                    rows: number;
+                }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('element-plus').InputProps> & Readonly<{
+                    onClear?: ((evt: MouseEvent | undefined) => any) | undefined;
+                    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                    onChange?: ((value: string, evt?: Event | undefined) => any) | undefined;
+                    onInput?: ((value: string) => any) | undefined;
+                    onFocus?: ((evt: FocusEvent) => any) | undefined;
+                    onBlur?: ((evt: FocusEvent) => any) | undefined;
+                    onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+                    onMouseenter?: ((evt: MouseEvent) => any) | undefined;
+                    onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;
+                    onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;
+                    onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;
+                    onCompositionend?: ((evt: CompositionEvent) => any) | undefined;
+                }>, {
+                    input: import('vue').ShallowRef<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+                    textarea: import('vue').ShallowRef<HTMLTextAreaElement | undefined, HTMLTextAreaElement | undefined>;
+                    ref: import('vue').ComputedRef<HTMLInputElement | HTMLTextAreaElement | undefined>;
+                    textareaStyle: import('vue').ComputedRef<import('vue').StyleValue>;
+                    autosize: import('vue').Ref<import('element-plus').InputAutoSize | undefined, import('element-plus').InputAutoSize | undefined>;
+                    isComposing: import('vue').Ref<boolean, boolean>;
+                    passwordVisible: import('vue').Ref<boolean, boolean>;
+                    focus: () => void | undefined;
+                    blur: () => void | undefined;
+                    select: () => void;
+                    clear: (evt?: MouseEvent) => void;
+                    resizeTextarea: () => void;
+                }, {}, {}, {}, {
+                    type: import('element-plus').InputType;
+                    modelValue: string | number | null;
+                    disabled: boolean;
+                    modelModifiers: import('element-plus').InputModelModifiers;
+                    autocomplete: string;
+                    clearIcon: import('element-plus/es/utils/vue/icon.mjs').IconPropType;
+                    wordLimitPosition: "inside" | "outside";
+                    tabindex: string | number;
+                    validateEvent: boolean;
+                    inputStyle: string | false | import('vue').CSSProperties | import('vue').StyleValue[] | null;
+                    rows: number;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').InputProps> & Readonly<{
+                onClear?: ((evt: MouseEvent | undefined) => any) | undefined;
+                "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                onChange?: ((value: string, evt?: Event | undefined) => any) | undefined;
+                onInput?: ((value: string) => any) | undefined;
+                onFocus?: ((evt: FocusEvent) => any) | undefined;
+                onBlur?: ((evt: FocusEvent) => any) | undefined;
+                onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+                onMouseenter?: ((evt: MouseEvent) => any) | undefined;
+                onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;
+                onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;
+                onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;
+                onCompositionend?: ((evt: CompositionEvent) => any) | undefined;
+            }>, {
+                input: import('vue').ShallowRef<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+                textarea: import('vue').ShallowRef<HTMLTextAreaElement | undefined, HTMLTextAreaElement | undefined>;
+                ref: import('vue').ComputedRef<HTMLInputElement | HTMLTextAreaElement | undefined>;
+                textareaStyle: import('vue').ComputedRef<import('vue').StyleValue>;
+                autosize: import('vue').Ref<import('element-plus').InputAutoSize | undefined, import('element-plus').InputAutoSize | undefined>;
+                isComposing: import('vue').Ref<boolean, boolean>;
+                passwordVisible: import('vue').Ref<boolean, boolean>;
+                focus: () => void | undefined;
+                blur: () => void | undefined;
+                select: () => void;
+                clear: (evt?: MouseEvent) => void;
+                resizeTextarea: () => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                clear: (evt: MouseEvent | undefined) => void;
+                "update:modelValue": (value: string) => void;
+                change: (value: string, evt?: Event | undefined) => void;
+                input: (value: string) => void;
+                focus: (evt: FocusEvent) => void;
+                blur: (evt: FocusEvent) => void;
+                mouseleave: (evt: MouseEvent) => void;
+                mouseenter: (evt: MouseEvent) => void;
+                keydown: (evt: Event | KeyboardEvent) => void;
+                compositionstart: (evt: CompositionEvent) => void;
+                compositionupdate: (evt: CompositionEvent) => void;
+                compositionend: (evt: CompositionEvent) => void;
+            }, string, {
+                type: import('element-plus').InputType;
+                modelValue: string | number | null;
+                disabled: boolean;
+                modelModifiers: import('element-plus').InputModelModifiers;
+                autocomplete: string;
+                clearIcon: import('element-plus/es/utils/vue/icon.mjs').IconPropType;
+                wordLimitPosition: "inside" | "outside";
+                tabindex: string | number;
+                validateEvent: boolean;
+                inputStyle: string | false | import('vue').CSSProperties | import('vue').StyleValue[] | null;
+                rows: number;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    prepend?: (props: {}) => any;
+                } & {
+                    prefix?: (props: {}) => any;
+                } & {
+                    suffix?: (props: {}) => any;
+                } & {
+                    'password-icon'?: (props: {
+                        visible: boolean;
+                    }) => any;
+                } & {
+                    append?: (props: {}) => any;
+                };
+            })>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;