yuang-framework-ui-pc 1.1.41 → 1.1.42

package/es/ele-cropper/index.d.ts

@@ -3,7 +3,7 @@ import { CropperOptions } from './types';
 import { default as PreviewType } from './components/cropper-preview';
 
 export type PreviewInstance = InstanceType<typeof PreviewType> | null;
-declare const _default: import('vue').DefineComponent<{
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     height: StringConstructor;
     src: StringConstructor;
     imageType: {
@@ -40,9 +40,9 @@ declare const _default: import('vue').DefineComponent<{
         default: null;
     };
     locale: import('vue').PropType<Partial<import('./types').CropperLocale>>;
-}, {
-    imageRef: Ref<HTMLImageElement | null>;
-    previewRef: Ref<PreviewInstance>;
+}>, {
+    imageRef: Ref<HTMLImageElement | null, HTMLImageElement | null>;
+    previewRef: Ref<PreviewInstance, PreviewInstance>;
     isResponsive: import('vue').ComputedRef<boolean>;
     handleZoomIn: () => void;
     handleZoomOut: () => void;
@@ -60,7 +60,7 @@ declare const _default: import('vue').DefineComponent<{
         type: string;
     }) => void;
     handleOk: () => void;
-}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     done: (_result?: Blob | string | null) => boolean;
 }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     height: StringConstructor;
@@ -99,9 +99,9 @@ declare const _default: import('vue').DefineComponent<{
         default: null;
     };
     locale: import('vue').PropType<Partial<import('./types').CropperLocale>>;
-}>> & {
+}>> & Readonly<{
     onDone?: ((_result?: string | Blob | null | undefined) => any) | undefined;
-}, {
+}>, {
     tooltip: boolean;
     preview: boolean;
     responsive: boolean;
@@ -110,5 +110,2715 @@ declare const _default: import('vue').DefineComponent<{
     tools: string;
     previewWidth: number;
     toBlob: boolean;
-}, {}>;
+}, {}, {
+    CropperPreview: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        previewWidth: {
+            type: NumberConstructor;
+            required: true;
+        };
+        aspectRatio: NumberConstructor;
+    }>, {
+        rootRef: Ref<HTMLDivElement | null, HTMLDivElement | null>;
+        getPreviews: () => NodeListOf<HTMLElement> | undefined;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        previewWidth: {
+            type: NumberConstructor;
+            required: true;
+        };
+        aspectRatio: NumberConstructor;
+    }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    CropperTools: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        tools: StringConstructor;
+        accept: StringConstructor;
+        tooltip: BooleanConstructor;
+        tooltipProps: import('vue').PropType<import('../ele-app/plus').EleTooltipProps>;
+        beforeUploadClick: import('vue').PropType<import('./types').BeforeUploadClick>;
+        locale: import('vue').PropType<Partial<import('./types').CropperLocale>>;
+    }>, {
+        lang: import('vue').ComputedRef<import('./types').CropperLocale>;
+        tooltipRef: Ref<import('../ele-app/plus').EleTooltipInstance, import('../ele-app/plus').EleTooltipInstance>;
+        groups: import('vue').ShallowRef<import('./types').ToolGroup[], import('./types').ToolGroup[]>;
+        tooltipContent: Ref<string, string>;
+        virtualRef: Ref<any, any>;
+        handleUpload: (file: File) => boolean;
+        handleClick: (name: Omit<import('./types').ToolName, "upload">) => void;
+        handleItemHover: (item: import('./types').ToolItem, e: MouseEvent) => void;
+        handleUploadButtonClick: (e: MouseEvent) => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        zoomIn: () => true;
+        zoomOut: () => true;
+        moveLeft: () => true;
+        moveRight: () => true;
+        moveUp: () => true;
+        moveDown: () => true;
+        rotateLeft: () => true;
+        rotateRight: () => true;
+        flipX: () => true;
+        flipY: () => true;
+        reset: () => true;
+        upload: (_option?: import('./types').UploadOption) => true;
+        ok: () => true;
+    }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        tools: StringConstructor;
+        accept: StringConstructor;
+        tooltip: BooleanConstructor;
+        tooltipProps: import('vue').PropType<import('../ele-app/plus').EleTooltipProps>;
+        beforeUploadClick: import('vue').PropType<import('./types').BeforeUploadClick>;
+        locale: import('vue').PropType<Partial<import('./types').CropperLocale>>;
+    }>> & Readonly<{
+        onReset?: (() => any) | undefined;
+        onZoomIn?: (() => any) | undefined;
+        onZoomOut?: (() => any) | undefined;
+        onMoveLeft?: (() => any) | undefined;
+        onMoveRight?: (() => any) | undefined;
+        onMoveUp?: (() => any) | undefined;
+        onMoveDown?: (() => any) | undefined;
+        onRotateLeft?: (() => any) | undefined;
+        onRotateRight?: (() => any) | undefined;
+        onFlipX?: (() => any) | undefined;
+        onFlipY?: (() => any) | undefined;
+        onUpload?: ((_option?: import('./types').UploadOption | undefined) => any) | undefined;
+        onOk?: (() => any) | undefined;
+    }>, {
+        tooltip: boolean;
+    }, {}, {
+        ElButtonGroup: {
+            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+                readonly size: {
+                    readonly type: import('vue').PropType<"" | "small" | "default" | "large">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly type: {
+                    readonly type: import('vue').PropType<"" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+            }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+                readonly type: "" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text";
+            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import('vue').ExtractPropTypes<{
+                readonly size: {
+                    readonly type: import('vue').PropType<"" | "small" | "default" | "large">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly type: {
+                    readonly type: import('vue').PropType<"" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+            }>>, {}, {}, {}, {}, {
+                readonly type: "" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text";
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+            readonly size: {
+                readonly type: import('vue').PropType<"" | "small" | "default" | "large">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly type: {
+                readonly type: import('vue').PropType<"" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+        }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
+            readonly type: "" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text";
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) & import('vue').Plugin;
+        ElButton: ({
+            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+                readonly size: {
+                    readonly type: import('vue').PropType<"" | "small" | "default" | "large">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly disabled: BooleanConstructor;
+                readonly type: {
+                    readonly type: import('vue').PropType<"" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly icon: {
+                    readonly type: import('vue').PropType<string | import('vue').Component>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly nativeType: {
+                    readonly type: import('vue').PropType<"reset" | "submit" | "button">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "button";
+                };
+                readonly loading: BooleanConstructor;
+                readonly loadingIcon: {
+                    readonly type: import('vue').PropType<string | import('vue').Component>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => any;
+                };
+                readonly plain: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: undefined;
+                };
+                readonly text: BooleanConstructor;
+                readonly link: BooleanConstructor;
+                readonly bg: BooleanConstructor;
+                readonly autofocus: BooleanConstructor;
+                readonly round: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: undefined;
+                };
+                readonly circle: BooleanConstructor;
+                readonly color: StringConstructor;
+                readonly dark: BooleanConstructor;
+                readonly autoInsertSpace: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: undefined;
+                };
+                readonly tag: {
+                    readonly type: import('vue').PropType<string | import('vue').Component>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "button";
+                };
+            }>> & {
+                onClick?: ((evt: MouseEvent) => any) | undefined;
+            }, {
+                ref: Ref<HTMLButtonElement | undefined>;
+                size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
+                type: import('vue').ComputedRef<string>;
+                disabled: import('vue').ComputedRef<boolean>;
+                shouldAddSpace: import('vue').ComputedRef<boolean>;
+            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                click: (evt: MouseEvent) => void;
+            }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+                readonly link: boolean;
+                readonly circle: boolean;
+                readonly text: boolean;
+                readonly disabled: boolean;
+                readonly round: boolean;
+                readonly dark: boolean;
+                readonly type: "" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text";
+                readonly bg: boolean;
+                readonly loading: boolean;
+                readonly autofocus: boolean;
+                readonly tag: string | import('vue').Component;
+                readonly plain: boolean;
+                readonly nativeType: "reset" | "submit" | "button";
+                readonly loadingIcon: string | import('vue').Component;
+                readonly autoInsertSpace: boolean;
+            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import('vue').ExtractPropTypes<{
+                readonly size: {
+                    readonly type: import('vue').PropType<"" | "small" | "default" | "large">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly disabled: BooleanConstructor;
+                readonly type: {
+                    readonly type: import('vue').PropType<"" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly icon: {
+                    readonly type: import('vue').PropType<string | import('vue').Component>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly nativeType: {
+                    readonly type: import('vue').PropType<"reset" | "submit" | "button">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "button";
+                };
+                readonly loading: BooleanConstructor;
+                readonly loadingIcon: {
+                    readonly type: import('vue').PropType<string | import('vue').Component>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => any;
+                };
+                readonly plain: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: undefined;
+                };
+                readonly text: BooleanConstructor;
+                readonly link: BooleanConstructor;
+                readonly bg: BooleanConstructor;
+                readonly autofocus: BooleanConstructor;
+                readonly round: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: undefined;
+                };
+                readonly circle: BooleanConstructor;
+                readonly color: StringConstructor;
+                readonly dark: BooleanConstructor;
+                readonly autoInsertSpace: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: undefined;
+                };
+                readonly tag: {
+                    readonly type: import('vue').PropType<string | import('vue').Component>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "button";
+                };
+            }>> & {
+                onClick?: ((evt: MouseEvent) => any) | undefined;
+            }, {
+                ref: Ref<HTMLButtonElement | undefined>;
+                size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
+                type: import('vue').ComputedRef<string>;
+                disabled: import('vue').ComputedRef<boolean>;
+                shouldAddSpace: import('vue').ComputedRef<boolean>;
+            }, {}, {}, {}, {
+                readonly link: boolean;
+                readonly circle: boolean;
+                readonly text: boolean;
+                readonly disabled: boolean;
+                readonly round: boolean;
+                readonly dark: boolean;
+                readonly type: "" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text";
+                readonly bg: boolean;
+                readonly loading: boolean;
+                readonly autofocus: boolean;
+                readonly tag: string | import('vue').Component;
+                readonly plain: boolean;
+                readonly nativeType: "reset" | "submit" | "button";
+                readonly loadingIcon: string | import('vue').Component;
+                readonly autoInsertSpace: boolean;
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+            readonly size: {
+                readonly type: import('vue').PropType<"" | "small" | "default" | "large">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly disabled: BooleanConstructor;
+            readonly type: {
+                readonly type: import('vue').PropType<"" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly icon: {
+                readonly type: import('vue').PropType<string | import('vue').Component>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly nativeType: {
+                readonly type: import('vue').PropType<"reset" | "submit" | "button">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "button";
+            };
+            readonly loading: BooleanConstructor;
+            readonly loadingIcon: {
+                readonly type: import('vue').PropType<string | import('vue').Component>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => any;
+            };
+            readonly plain: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            readonly text: BooleanConstructor;
+            readonly link: BooleanConstructor;
+            readonly bg: BooleanConstructor;
+            readonly autofocus: BooleanConstructor;
+            readonly round: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            readonly circle: BooleanConstructor;
+            readonly color: StringConstructor;
+            readonly dark: BooleanConstructor;
+            readonly autoInsertSpace: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            readonly tag: {
+                readonly type: import('vue').PropType<string | import('vue').Component>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "button";
+            };
+        }>> & {
+            onClick?: ((evt: MouseEvent) => any) | undefined;
+        }, {
+            ref: Ref<HTMLButtonElement | undefined>;
+            size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
+            type: import('vue').ComputedRef<string>;
+            disabled: import('vue').ComputedRef<boolean>;
+            shouldAddSpace: import('vue').ComputedRef<boolean>;
+        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            click: (evt: MouseEvent) => void;
+        }, string, {
+            readonly link: boolean;
+            readonly circle: boolean;
+            readonly text: boolean;
+            readonly disabled: boolean;
+            readonly round: boolean;
+            readonly dark: boolean;
+            readonly type: "" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text";
+            readonly bg: boolean;
+            readonly loading: boolean;
+            readonly autofocus: boolean;
+            readonly tag: string | import('vue').Component;
+            readonly plain: boolean;
+            readonly nativeType: "reset" | "submit" | "button";
+            readonly loadingIcon: string | import('vue').Component;
+            readonly autoInsertSpace: boolean;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+            $slots: {
+                loading?(_: {}): any;
+                icon?(_: {}): any;
+                default?(_: {}): any;
+            };
+        }) & import('vue').Plugin) & {
+            ButtonGroup: {
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+                    readonly size: {
+                        readonly type: import('vue').PropType<"" | "small" | "default" | "large">;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly type: {
+                        readonly type: import('vue').PropType<"" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text">;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "";
+                    };
+                }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+                    readonly type: "" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text";
+                }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('vue').ExtractPropTypes<{
+                    readonly size: {
+                        readonly type: import('vue').PropType<"" | "small" | "default" | "large">;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly type: {
+                        readonly type: import('vue').PropType<"" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text">;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "";
+                    };
+                }>>, {}, {}, {}, {}, {
+                    readonly type: "" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text";
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                readonly size: {
+                    readonly type: import('vue').PropType<"" | "small" | "default" | "large">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly type: {
+                    readonly type: import('vue').PropType<"" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+            }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
+                readonly type: "" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text";
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    default?(_: {}): any;
+                };
+            });
+        };
+        ElUpload: {
+            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+                readonly beforeUpload: {
+                    readonly type: import('vue').PropType<(rawFile: import('element-plus').UploadRawFile) => boolean | void | Blob | File | Promise<boolean | void | Blob | File | null | undefined> | null | undefined>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => void;
+                };
+                readonly beforeRemove: {
+                    readonly type: import('vue').PropType<(uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => boolean | Promise<boolean>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onRemove: {
+                    readonly type: import('vue').PropType<(uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => void;
+                };
+                readonly onChange: {
+                    readonly type: import('vue').PropType<(uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => void;
+                };
+                readonly onPreview: {
+                    readonly type: import('vue').PropType<(uploadFile: import('element-plus').UploadFile) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => void;
+                };
+                readonly onSuccess: {
+                    readonly type: import('vue').PropType<(response: any, uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => void;
+                };
+                readonly onProgress: {
+                    readonly type: import('vue').PropType<(evt: import('element-plus').UploadProgressEvent, uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => void;
+                };
+                readonly onError: {
+                    readonly type: import('vue').PropType<(error: Error, uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => void;
+                };
+                readonly onExceed: {
+                    readonly type: import('vue').PropType<(files: File[], uploadFiles: import('element-plus').UploadUserFile[]) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => void;
+                };
+                readonly crossorigin: {
+                    readonly type: import('vue').PropType<"" | "anonymous" | "use-credentials">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly action: {
+                    readonly type: import('vue').PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "#";
+                };
+                readonly headers: {
+                    readonly type: import('vue').PropType<Record<string, any> | Headers>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly method: {
+                    readonly type: import('vue').PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "post";
+                };
+                readonly data: {
+                    readonly type: import('vue').PropType<({
+                        [x: string]: any;
+                    } | Promise<{
+                        [x: string]: any;
+                    }>) | ((rawFile: import('element-plus').UploadRawFile) => {
+                        [x: string]: any;
+                    } | Promise<{
+                        [x: string]: any;
+                    }>)>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => {};
+                };
+                readonly multiple: BooleanConstructor;
+                readonly name: {
+                    readonly type: import('vue').PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "file";
+                };
+                readonly drag: BooleanConstructor;
+                readonly withCredentials: BooleanConstructor;
+                readonly showFileList: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                readonly accept: {
+                    readonly type: import('vue').PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly fileList: {
+                    readonly type: import('vue').PropType<import('element-plus').UploadUserFile[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => [];
+                };
+                readonly autoUpload: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                readonly listType: {
+                    readonly type: import('vue').PropType<"text" | "picture" | "picture-card">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "text";
+                };
+                readonly httpRequest: {
+                    readonly type: import('vue').PropType<import('element-plus').UploadRequestHandler>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: import('element-plus').UploadRequestHandler;
+                };
+                readonly disabled: BooleanConstructor;
+                readonly limit: NumberConstructor;
+            }>>, {
+                abort: (file: import('element-plus').UploadFile) => void;
+                submit: () => void;
+                clearFiles: (states?: import('element-plus').UploadStatus[]) => void;
+                handleStart: (rawFile: import('element-plus').UploadRawFile) => void;
+                handleRemove: (file: import('element-plus').UploadFile | import('element-plus').UploadRawFile, rawFile?: import('element-plus').UploadRawFile) => void;
+            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+                readonly data: ({
+                    [x: string]: any;
+                } | Promise<{
+                    [x: string]: any;
+                }>) | ((rawFile: import('element-plus').UploadRawFile) => {
+                    [x: string]: any;
+                } | Promise<{
+                    [x: string]: any;
+                }>);
+                readonly disabled: boolean;
+                readonly drag: boolean;
+                readonly multiple: boolean;
+                readonly name: string;
+                readonly onChange: (uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
+                readonly onError: (error: Error, uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
+                readonly onProgress: (evt: import('element-plus').UploadProgressEvent, uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
+                readonly method: string;
+                readonly action: string;
+                readonly withCredentials: boolean;
+                readonly showFileList: boolean;
+                readonly accept: string;
+                readonly fileList: import('element-plus').UploadUserFile[];
+                readonly autoUpload: boolean;
+                readonly listType: "text" | "picture" | "picture-card";
+                readonly httpRequest: import('element-plus').UploadRequestHandler;
+                readonly beforeUpload: (rawFile: import('element-plus').UploadRawFile) => boolean | void | Blob | File | Promise<boolean | void | Blob | File | null | undefined> | null | undefined;
+                readonly onRemove: (uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
+                readonly onPreview: (uploadFile: import('element-plus').UploadFile) => void;
+                readonly onSuccess: (response: any, uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
+                readonly onExceed: (files: File[], uploadFiles: import('element-plus').UploadUserFile[]) => void;
+            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import('vue').ExtractPropTypes<{
+                readonly beforeUpload: {
+                    readonly type: import('vue').PropType<(rawFile: import('element-plus').UploadRawFile) => boolean | void | Blob | File | Promise<boolean | void | Blob | File | null | undefined> | null | undefined>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => void;
+                };
+                readonly beforeRemove: {
+                    readonly type: import('vue').PropType<(uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => boolean | Promise<boolean>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly onRemove: {
+                    readonly type: import('vue').PropType<(uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => void;
+                };
+                readonly onChange: {
+                    readonly type: import('vue').PropType<(uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => void;
+                };
+                readonly onPreview: {
+                    readonly type: import('vue').PropType<(uploadFile: import('element-plus').UploadFile) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => void;
+                };
+                readonly onSuccess: {
+                    readonly type: import('vue').PropType<(response: any, uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => void;
+                };
+                readonly onProgress: {
+                    readonly type: import('vue').PropType<(evt: import('element-plus').UploadProgressEvent, uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => void;
+                };
+                readonly onError: {
+                    readonly type: import('vue').PropType<(error: Error, uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => void;
+                };
+                readonly onExceed: {
+                    readonly type: import('vue').PropType<(files: File[], uploadFiles: import('element-plus').UploadUserFile[]) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => void;
+                };
+                readonly crossorigin: {
+                    readonly type: import('vue').PropType<"" | "anonymous" | "use-credentials">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly action: {
+                    readonly type: import('vue').PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "#";
+                };
+                readonly headers: {
+                    readonly type: import('vue').PropType<Record<string, any> | Headers>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly method: {
+                    readonly type: import('vue').PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "post";
+                };
+                readonly data: {
+                    readonly type: import('vue').PropType<({
+                        [x: string]: any;
+                    } | Promise<{
+                        [x: string]: any;
+                    }>) | ((rawFile: import('element-plus').UploadRawFile) => {
+                        [x: string]: any;
+                    } | Promise<{
+                        [x: string]: any;
+                    }>)>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => {};
+                };
+                readonly multiple: BooleanConstructor;
+                readonly name: {
+                    readonly type: import('vue').PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "file";
+                };
+                readonly drag: BooleanConstructor;
+                readonly withCredentials: BooleanConstructor;
+                readonly showFileList: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                readonly accept: {
+                    readonly type: import('vue').PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly fileList: {
+                    readonly type: import('vue').PropType<import('element-plus').UploadUserFile[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => [];
+                };
+                readonly autoUpload: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                readonly listType: {
+                    readonly type: import('vue').PropType<"text" | "picture" | "picture-card">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "text";
+                };
+                readonly httpRequest: {
+                    readonly type: import('vue').PropType<import('element-plus').UploadRequestHandler>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: import('element-plus').UploadRequestHandler;
+                };
+                readonly disabled: BooleanConstructor;
+                readonly limit: NumberConstructor;
+            }>>, {
+                abort: (file: import('element-plus').UploadFile) => void;
+                submit: () => void;
+                clearFiles: (states?: import('element-plus').UploadStatus[]) => void;
+                handleStart: (rawFile: import('element-plus').UploadRawFile) => void;
+                handleRemove: (file: import('element-plus').UploadFile | import('element-plus').UploadRawFile, rawFile?: import('element-plus').UploadRawFile) => void;
+            }, {}, {}, {}, {
+                readonly data: ({
+                    [x: string]: any;
+                } | Promise<{
+                    [x: string]: any;
+                }>) | ((rawFile: import('element-plus').UploadRawFile) => {
+                    [x: string]: any;
+                } | Promise<{
+                    [x: string]: any;
+                }>);
+                readonly disabled: boolean;
+                readonly drag: boolean;
+                readonly multiple: boolean;
+                readonly name: string;
+                readonly onChange: (uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
+                readonly onError: (error: Error, uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
+                readonly onProgress: (evt: import('element-plus').UploadProgressEvent, uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
+                readonly method: string;
+                readonly action: string;
+                readonly withCredentials: boolean;
+                readonly showFileList: boolean;
+                readonly accept: string;
+                readonly fileList: import('element-plus').UploadUserFile[];
+                readonly autoUpload: boolean;
+                readonly listType: "text" | "picture" | "picture-card";
+                readonly httpRequest: import('element-plus').UploadRequestHandler;
+                readonly beforeUpload: (rawFile: import('element-plus').UploadRawFile) => boolean | void | Blob | File | Promise<boolean | void | Blob | File | null | undefined> | null | undefined;
+                readonly onRemove: (uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
+                readonly onPreview: (uploadFile: import('element-plus').UploadFile) => void;
+                readonly onSuccess: (response: any, uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
+                readonly onExceed: (files: File[], uploadFiles: import('element-plus').UploadUserFile[]) => void;
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+            readonly beforeUpload: {
+                readonly type: import('vue').PropType<(rawFile: import('element-plus').UploadRawFile) => boolean | void | Blob | File | Promise<boolean | void | Blob | File | null | undefined> | null | undefined>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => void;
+            };
+            readonly beforeRemove: {
+                readonly type: import('vue').PropType<(uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => boolean | Promise<boolean>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly onRemove: {
+                readonly type: import('vue').PropType<(uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => void;
+            };
+            readonly onChange: {
+                readonly type: import('vue').PropType<(uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => void;
+            };
+            readonly onPreview: {
+                readonly type: import('vue').PropType<(uploadFile: import('element-plus').UploadFile) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => void;
+            };
+            readonly onSuccess: {
+                readonly type: import('vue').PropType<(response: any, uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => void;
+            };
+            readonly onProgress: {
+                readonly type: import('vue').PropType<(evt: import('element-plus').UploadProgressEvent, uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => void;
+            };
+            readonly onError: {
+                readonly type: import('vue').PropType<(error: Error, uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => void;
+            };
+            readonly onExceed: {
+                readonly type: import('vue').PropType<(files: File[], uploadFiles: import('element-plus').UploadUserFile[]) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => void;
+            };
+            readonly crossorigin: {
+                readonly type: import('vue').PropType<"" | "anonymous" | "use-credentials">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly action: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "#";
+            };
+            readonly headers: {
+                readonly type: import('vue').PropType<Record<string, any> | Headers>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly method: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "post";
+            };
+            readonly data: {
+                readonly type: import('vue').PropType<({
+                    [x: string]: any;
+                } | Promise<{
+                    [x: string]: any;
+                }>) | ((rawFile: import('element-plus').UploadRawFile) => {
+                    [x: string]: any;
+                } | Promise<{
+                    [x: string]: any;
+                }>)>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => {};
+            };
+            readonly multiple: BooleanConstructor;
+            readonly name: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "file";
+            };
+            readonly drag: BooleanConstructor;
+            readonly withCredentials: BooleanConstructor;
+            readonly showFileList: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            readonly accept: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly fileList: {
+                readonly type: import('vue').PropType<import('element-plus').UploadUserFile[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => [];
+            };
+            readonly autoUpload: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            readonly listType: {
+                readonly type: import('vue').PropType<"text" | "picture" | "picture-card">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "text";
+            };
+            readonly httpRequest: {
+                readonly type: import('vue').PropType<import('element-plus').UploadRequestHandler>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: import('element-plus').UploadRequestHandler;
+            };
+            readonly disabled: BooleanConstructor;
+            readonly limit: NumberConstructor;
+        }>>, {
+            abort: (file: import('element-plus').UploadFile) => void;
+            submit: () => void;
+            clearFiles: (states?: import('element-plus').UploadStatus[]) => void;
+            handleStart: (rawFile: import('element-plus').UploadRawFile) => void;
+            handleRemove: (file: import('element-plus').UploadFile | import('element-plus').UploadRawFile, rawFile?: import('element-plus').UploadRawFile) => void;
+        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
+            readonly data: ({
+                [x: string]: any;
+            } | Promise<{
+                [x: string]: any;
+            }>) | ((rawFile: import('element-plus').UploadRawFile) => {
+                [x: string]: any;
+            } | Promise<{
+                [x: string]: any;
+            }>);
+            readonly disabled: boolean;
+            readonly drag: boolean;
+            readonly multiple: boolean;
+            readonly name: string;
+            readonly onChange: (uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
+            readonly onError: (error: Error, uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
+            readonly onProgress: (evt: import('element-plus').UploadProgressEvent, uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
+            readonly method: string;
+            readonly action: string;
+            readonly withCredentials: boolean;
+            readonly showFileList: boolean;
+            readonly accept: string;
+            readonly fileList: import('element-plus').UploadUserFile[];
+            readonly autoUpload: boolean;
+            readonly listType: "text" | "picture" | "picture-card";
+            readonly httpRequest: import('element-plus').UploadRequestHandler;
+            readonly beforeUpload: (rawFile: import('element-plus').UploadRawFile) => boolean | void | Blob | File | Promise<boolean | void | Blob | File | null | undefined> | null | undefined;
+            readonly onRemove: (uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
+            readonly onPreview: (uploadFile: import('element-plus').UploadFile) => void;
+            readonly onSuccess: (response: any, uploadFile: import('element-plus').UploadFile, uploadFiles: import('element-plus').UploadFiles) => void;
+            readonly onExceed: (files: File[], uploadFiles: import('element-plus').UploadUserFile[]) => void;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+            $slots: {
+                file?(_: {
+                    file: import('element-plus').UploadFile;
+                    index: number;
+                }): any;
+                file?(_: {
+                    file: import('element-plus').UploadFile;
+                    index: number;
+                }): any;
+                trigger?(_: {}): any;
+                trigger?(_: {}): any;
+                default?(_: {}): any;
+                default?(_: {}): any;
+                default?(_: {}): any;
+                tip?(_: {}): any;
+            };
+        }) & import('vue').Plugin;
+        EleTooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            bodyStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+            bg: StringConstructor;
+            arrowBg: StringConstructor;
+            width: (NumberConstructor | StringConstructor)[];
+            isPopover: BooleanConstructor;
+            showAfter: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            hideAfter: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 200;
+            };
+            autoClose: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            effect: {
+                readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "dark";
+            };
+            ariaLabel: StringConstructor;
+            placement: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "bottom";
+            };
+            teleported: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            appendTo: {
+                readonly type: import('vue').PropType<string | HTMLElement>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            disabled: BooleanConstructor;
+            offset: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 12;
+            };
+            persistent: BooleanConstructor;
+            zIndex: NumberConstructor;
+            visible: {
+                readonly type: import('vue').PropType<boolean | null>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: null;
+            };
+            trigger: {
+                readonly type: import('vue').PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "hover";
+            };
+            triggerKeys: {
+                readonly type: import('vue').PropType<string[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => string[];
+            };
+            popperOptions: {
+                readonly type: import('vue').PropType<any>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => {};
+            };
+            transition: StringConstructor;
+            content: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            enterable: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            showArrow: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: boolean;
+            };
+            arrowOffset: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 5;
+            };
+            virtualRef: {
+                readonly type: import('vue').PropType<import('element-plus').Measurable>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            virtualTriggering: BooleanConstructor;
+            rawContent: BooleanConstructor;
+            gpuAcceleration: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            className: StringConstructor;
+            popperClass: StringConstructor;
+            popperStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+        }>, {
+            tooltipRef: Ref<import('../ele-app/el').ElTooltipInstance | undefined, import('../ele-app/el').ElTooltipInstance | undefined>;
+            rootProps: import('vue').ComputedRef<Partial<import('element-plus').ElTooltipProps>>;
+            popperRef: import('vue').ComputedRef<import('../ele-app/el').ElPopperInstance>;
+            contentRef: import('vue').ComputedRef<import('element-plus').TooltipContentInstance | undefined>;
+            isFocusInsideContent: () => void;
+            updatePopper: () => void;
+            handleOpen: (opt?: Event) => void;
+            handleClose: (opt?: Event) => void;
+            hide: (opt?: Event) => void;
+            handleUpdateVisible: (visible: boolean) => void;
+            handlePopBeforeShow: (e: Event) => void;
+            handlePopBeforeHide: (e: Event) => void;
+            handlePopShow: (e: Event) => void;
+            handlePopHide: (e: Event) => void;
+            handlePopOpen: (e: any) => void;
+            handlePopClose: (e: any) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, import('../ele-tooltip/props').TooltipEmits, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            bodyStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+            bg: StringConstructor;
+            arrowBg: StringConstructor;
+            width: (NumberConstructor | StringConstructor)[];
+            isPopover: BooleanConstructor;
+            showAfter: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            hideAfter: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 200;
+            };
+            autoClose: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            effect: {
+                readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "dark";
+            };
+            ariaLabel: StringConstructor;
+            placement: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "bottom";
+            };
+            teleported: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            appendTo: {
+                readonly type: import('vue').PropType<string | HTMLElement>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            disabled: BooleanConstructor;
+            offset: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 12;
+            };
+            persistent: BooleanConstructor;
+            zIndex: NumberConstructor;
+            visible: {
+                readonly type: import('vue').PropType<boolean | null>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: null;
+            };
+            trigger: {
+                readonly type: import('vue').PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "hover";
+            };
+            triggerKeys: {
+                readonly type: import('vue').PropType<string[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => string[];
+            };
+            popperOptions: {
+                readonly type: import('vue').PropType<any>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => {};
+            };
+            transition: StringConstructor;
+            content: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            enterable: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            showArrow: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: boolean;
+            };
+            arrowOffset: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 5;
+            };
+            virtualRef: {
+                readonly type: import('vue').PropType<import('element-plus').Measurable>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            virtualTriggering: BooleanConstructor;
+            rawContent: BooleanConstructor;
+            gpuAcceleration: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            className: StringConstructor;
+            popperClass: StringConstructor;
+            popperStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+        }>> & Readonly<{
+            onClose?: ((e: any) => any) | undefined;
+            onHide?: ((e: Event) => any) | undefined;
+            onOpen?: ((e: any) => any) | undefined;
+            "onUpdate:visible"?: ((visible: boolean) => any) | undefined;
+            "onBefore-show"?: ((e: Event) => any) | undefined;
+            "onBefore-hide"?: ((e: Event) => any) | undefined;
+            onShow?: ((e: Event) => any) | undefined;
+        }>, {
+            showAfter: number;
+            hideAfter: number;
+            autoClose: number;
+            effect: import('element-plus').PopperEffect;
+            placement: string;
+            teleported: boolean;
+            disabled: boolean;
+            offset: number;
+            persistent: boolean;
+            visible: boolean | null;
+            trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
+            triggerKeys: string[];
+            popperOptions: any;
+            content: string;
+            enterable: boolean;
+            showArrow: boolean;
+            arrowOffset: number;
+            virtualTriggering: boolean;
+            rawContent: boolean;
+            gpuAcceleration: boolean;
+            isPopover: boolean;
+        }, {}, {
+            ElTooltip: {
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+                    showArrow: {
+                        readonly type: import('vue').PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: boolean;
+                    };
+                    arrowOffset: {
+                        readonly type: import('vue').PropType<number>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: 5;
+                    };
+                    disabled: BooleanConstructor;
+                    trigger: {
+                        readonly type: import('vue').PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "hover";
+                    };
+                    triggerKeys: {
+                        readonly type: import('vue').PropType<string[]>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: () => string[];
+                    };
+                    virtualRef: {
+                        readonly type: import('vue').PropType<import('element-plus').Measurable>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    virtualTriggering: BooleanConstructor;
+                    onMouseenter: {
+                        readonly type: import('vue').PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    onMouseleave: {
+                        readonly type: import('vue').PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    onClick: {
+                        readonly type: import('vue').PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    onKeydown: {
+                        readonly type: import('vue').PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    onFocus: {
+                        readonly type: import('vue').PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    onBlur: {
+                        readonly type: import('vue').PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    onContextmenu: {
+                        readonly type: import('vue').PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    id: StringConstructor;
+                    open: BooleanConstructor;
+                    ariaLabel: StringConstructor;
+                    appendTo: {
+                        readonly type: import('vue').PropType<string | HTMLElement>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    content: {
+                        readonly type: import('vue').PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "";
+                    };
+                    rawContent: BooleanConstructor;
+                    persistent: BooleanConstructor;
+                    visible: {
+                        readonly type: import('vue').PropType<boolean | null>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: null;
+                    };
+                    transition: StringConstructor;
+                    teleported: {
+                        readonly type: import('vue').PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: true;
+                    };
+                    style: {
+                        readonly type: import('vue').PropType<import('vue').StyleValue>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    className: {
+                        readonly type: import('vue').PropType<string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | any[] | {
+                            [x: string]: boolean;
+                        })[])[])[])[])[])[])[])[])[])[]>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    effect: {
+                        readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "dark";
+                    };
+                    enterable: {
+                        readonly type: import('vue').PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: true;
+                    };
+                    pure: BooleanConstructor;
+                    focusOnShow: {
+                        readonly type: import('vue').PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: false;
+                    };
+                    trapping: {
+                        readonly type: import('vue').PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: false;
+                    };
+                    popperClass: {
+                        readonly type: import('vue').PropType<string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | any[] | {
+                            [x: string]: boolean;
+                        })[])[])[])[])[])[])[])[])[])[]>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    popperStyle: {
+                        readonly type: import('vue').PropType<import('vue').StyleValue>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    referenceEl: {
+                        readonly type: import('vue').PropType<HTMLElement>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    triggerTargetEl: {
+                        readonly type: import('vue').PropType<HTMLElement>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    stopPopperMouseEvent: {
+                        readonly type: import('vue').PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: true;
+                    };
+                    zIndex: NumberConstructor;
+                    boundariesPadding: {
+                        readonly type: import('vue').PropType<number>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: 0;
+                    };
+                    fallbackPlacements: {
+                        readonly type: import('vue').PropType<Placement[]>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: undefined;
+                    };
+                    gpuAcceleration: {
+                        readonly type: import('vue').PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: true;
+                    };
+                    offset: {
+                        readonly type: import('vue').PropType<number>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: 12;
+                    };
+                    placement: {
+                        readonly type: import('vue').PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "bottom";
+                    };
+                    popperOptions: {
+                        readonly type: import('vue').PropType<any>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: () => {};
+                    };
+                    strategy: {
+                        readonly type: import('vue').PropType<"fixed" | "absolute">;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "absolute";
+                    };
+                    showAfter: {
+                        readonly type: import('vue').PropType<number>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: 0;
+                    };
+                    hideAfter: {
+                        readonly type: import('vue').PropType<number>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: 200;
+                    };
+                    autoClose: {
+                        readonly type: import('vue').PropType<number>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: 0;
+                    };
+                    "onUpdate:visible": {
+                        readonly type: import('vue').PropType<(val: boolean) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    role: {
+                        readonly type: import('vue').PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "tooltip";
+                    };
+                }>>, {
+                    popperRef: Ref<import('element-plus').PopperInstance | undefined>;
+                    contentRef: Ref<import('element-plus').TooltipContentInstance | undefined>;
+                    isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+                    updatePopper: () => void;
+                    onOpen: (event?: Event) => void;
+                    onClose: (event?: Event) => void;
+                    hide: (event?: Event) => void;
+                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    [x: string]: (...args: any[]) => void;
+                }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+                    disabled: boolean;
+                    content: string;
+                    offset: number;
+                    visible: boolean | null;
+                    open: boolean;
+                    placement: string;
+                    strategy: "fixed" | "absolute";
+                    effect: import('element-plus').PopperEffect;
+                    showAfter: number;
+                    hideAfter: number;
+                    autoClose: number;
+                    trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
+                    role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
+                    virtualTriggering: boolean;
+                    arrowOffset: number;
+                    boundariesPadding: number;
+                    fallbackPlacements: Placement[];
+                    gpuAcceleration: boolean;
+                    popperOptions: Partial<Options>;
+                    enterable: boolean;
+                    focusOnShow: boolean;
+                    trapping: boolean;
+                    stopPopperMouseEvent: boolean;
+                    pure: boolean;
+                    triggerKeys: string[];
+                    teleported: boolean;
+                    rawContent: boolean;
+                    persistent: boolean;
+                    showArrow: boolean;
+                }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('vue').ExtractPropTypes<{
+                    showArrow: {
+                        readonly type: import('vue').PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: boolean;
+                    };
+                    arrowOffset: {
+                        readonly type: import('vue').PropType<number>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: 5;
+                    };
+                    disabled: BooleanConstructor;
+                    trigger: {
+                        readonly type: import('vue').PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "hover";
+                    };
+                    triggerKeys: {
+                        readonly type: import('vue').PropType<string[]>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: () => string[];
+                    };
+                    virtualRef: {
+                        readonly type: import('vue').PropType<import('element-plus').Measurable>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    virtualTriggering: BooleanConstructor;
+                    onMouseenter: {
+                        readonly type: import('vue').PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    onMouseleave: {
+                        readonly type: import('vue').PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    onClick: {
+                        readonly type: import('vue').PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    onKeydown: {
+                        readonly type: import('vue').PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    onFocus: {
+                        readonly type: import('vue').PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    onBlur: {
+                        readonly type: import('vue').PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    onContextmenu: {
+                        readonly type: import('vue').PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    id: StringConstructor;
+                    open: BooleanConstructor;
+                    ariaLabel: StringConstructor;
+                    appendTo: {
+                        readonly type: import('vue').PropType<string | HTMLElement>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    content: {
+                        readonly type: import('vue').PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "";
+                    };
+                    rawContent: BooleanConstructor;
+                    persistent: BooleanConstructor;
+                    visible: {
+                        readonly type: import('vue').PropType<boolean | null>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: null;
+                    };
+                    transition: StringConstructor;
+                    teleported: {
+                        readonly type: import('vue').PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: true;
+                    };
+                    style: {
+                        readonly type: import('vue').PropType<import('vue').StyleValue>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    className: {
+                        readonly type: import('vue').PropType<string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | any[] | {
+                            [x: string]: boolean;
+                        })[])[])[])[])[])[])[])[])[])[]>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    effect: {
+                        readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "dark";
+                    };
+                    enterable: {
+                        readonly type: import('vue').PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: true;
+                    };
+                    pure: BooleanConstructor;
+                    focusOnShow: {
+                        readonly type: import('vue').PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: false;
+                    };
+                    trapping: {
+                        readonly type: import('vue').PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: false;
+                    };
+                    popperClass: {
+                        readonly type: import('vue').PropType<string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | any[] | {
+                            [x: string]: boolean;
+                        })[])[])[])[])[])[])[])[])[])[]>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    popperStyle: {
+                        readonly type: import('vue').PropType<import('vue').StyleValue>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    referenceEl: {
+                        readonly type: import('vue').PropType<HTMLElement>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    triggerTargetEl: {
+                        readonly type: import('vue').PropType<HTMLElement>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    stopPopperMouseEvent: {
+                        readonly type: import('vue').PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: true;
+                    };
+                    zIndex: NumberConstructor;
+                    boundariesPadding: {
+                        readonly type: import('vue').PropType<number>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: 0;
+                    };
+                    fallbackPlacements: {
+                        readonly type: import('vue').PropType<Placement[]>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: undefined;
+                    };
+                    gpuAcceleration: {
+                        readonly type: import('vue').PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: true;
+                    };
+                    offset: {
+                        readonly type: import('vue').PropType<number>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: 12;
+                    };
+                    placement: {
+                        readonly type: import('vue').PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "bottom";
+                    };
+                    popperOptions: {
+                        readonly type: import('vue').PropType<any>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: () => {};
+                    };
+                    strategy: {
+                        readonly type: import('vue').PropType<"fixed" | "absolute">;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "absolute";
+                    };
+                    showAfter: {
+                        readonly type: import('vue').PropType<number>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: 0;
+                    };
+                    hideAfter: {
+                        readonly type: import('vue').PropType<number>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: 200;
+                    };
+                    autoClose: {
+                        readonly type: import('vue').PropType<number>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: 0;
+                    };
+                    "onUpdate:visible": {
+                        readonly type: import('vue').PropType<(val: boolean) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    role: {
+                        readonly type: import('vue').PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "tooltip";
+                    };
+                }>>, {
+                    popperRef: Ref<import('element-plus').PopperInstance | undefined>;
+                    contentRef: Ref<import('element-plus').TooltipContentInstance | undefined>;
+                    isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+                    updatePopper: () => void;
+                    onOpen: (event?: Event) => void;
+                    onClose: (event?: Event) => void;
+                    hide: (event?: Event) => void;
+                }, {}, {}, {}, {
+                    disabled: boolean;
+                    content: string;
+                    offset: number;
+                    visible: boolean | null;
+                    open: boolean;
+                    placement: string;
+                    strategy: "fixed" | "absolute";
+                    effect: import('element-plus').PopperEffect;
+                    showAfter: number;
+                    hideAfter: number;
+                    autoClose: number;
+                    trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
+                    role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
+                    virtualTriggering: boolean;
+                    arrowOffset: number;
+                    boundariesPadding: number;
+                    fallbackPlacements: Placement[];
+                    gpuAcceleration: boolean;
+                    popperOptions: Partial<Options>;
+                    enterable: boolean;
+                    focusOnShow: boolean;
+                    trapping: boolean;
+                    stopPopperMouseEvent: boolean;
+                    pure: boolean;
+                    triggerKeys: string[];
+                    teleported: boolean;
+                    rawContent: boolean;
+                    persistent: boolean;
+                    showArrow: boolean;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                showArrow: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: boolean;
+                };
+                arrowOffset: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 5;
+                };
+                disabled: BooleanConstructor;
+                trigger: {
+                    readonly type: import('vue').PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "hover";
+                };
+                triggerKeys: {
+                    readonly type: import('vue').PropType<string[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => string[];
+                };
+                virtualRef: {
+                    readonly type: import('vue').PropType<import('element-plus').Measurable>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                virtualTriggering: BooleanConstructor;
+                onMouseenter: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onMouseleave: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onClick: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onKeydown: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onFocus: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onBlur: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onContextmenu: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                id: StringConstructor;
+                open: BooleanConstructor;
+                ariaLabel: StringConstructor;
+                appendTo: {
+                    readonly type: import('vue').PropType<string | HTMLElement>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                content: {
+                    readonly type: import('vue').PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                rawContent: BooleanConstructor;
+                persistent: BooleanConstructor;
+                visible: {
+                    readonly type: import('vue').PropType<boolean | null>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: null;
+                };
+                transition: StringConstructor;
+                teleported: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                style: {
+                    readonly type: import('vue').PropType<import('vue').StyleValue>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                className: {
+                    readonly type: import('vue').PropType<string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | any[] | {
+                        [x: string]: boolean;
+                    })[])[])[])[])[])[])[])[])[])[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                effect: {
+                    readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "dark";
+                };
+                enterable: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                pure: BooleanConstructor;
+                focusOnShow: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: false;
+                };
+                trapping: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: false;
+                };
+                popperClass: {
+                    readonly type: import('vue').PropType<string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | any[] | {
+                        [x: string]: boolean;
+                    })[])[])[])[])[])[])[])[])[])[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                popperStyle: {
+                    readonly type: import('vue').PropType<import('vue').StyleValue>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                referenceEl: {
+                    readonly type: import('vue').PropType<HTMLElement>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                triggerTargetEl: {
+                    readonly type: import('vue').PropType<HTMLElement>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                stopPopperMouseEvent: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                zIndex: NumberConstructor;
+                boundariesPadding: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                fallbackPlacements: {
+                    readonly type: import('vue').PropType<Placement[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: undefined;
+                };
+                gpuAcceleration: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                offset: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 12;
+                };
+                placement: {
+                    readonly type: import('vue').PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "bottom";
+                };
+                popperOptions: {
+                    readonly type: import('vue').PropType<any>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => {};
+                };
+                strategy: {
+                    readonly type: import('vue').PropType<"fixed" | "absolute">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "absolute";
+                };
+                showAfter: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                hideAfter: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 200;
+                };
+                autoClose: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                "onUpdate:visible": {
+                    readonly type: import('vue').PropType<(val: boolean) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                role: {
+                    readonly type: import('vue').PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "tooltip";
+                };
+            }>>, {
+                popperRef: Ref<import('element-plus').PopperInstance | undefined>;
+                contentRef: Ref<import('element-plus').TooltipContentInstance | undefined>;
+                isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+                updatePopper: () => void;
+                onOpen: (event?: Event) => void;
+                onClose: (event?: Event) => void;
+                hide: (event?: Event) => void;
+            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                [x: string]: (...args: any[]) => void;
+            }, string, {
+                disabled: boolean;
+                content: string;
+                offset: number;
+                visible: boolean | null;
+                open: boolean;
+                placement: string;
+                strategy: "fixed" | "absolute";
+                effect: import('element-plus').PopperEffect;
+                showAfter: number;
+                hideAfter: number;
+                autoClose: number;
+                trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
+                role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
+                virtualTriggering: boolean;
+                arrowOffset: number;
+                boundariesPadding: number;
+                fallbackPlacements: Placement[];
+                gpuAcceleration: boolean;
+                popperOptions: Partial<Options>;
+                enterable: boolean;
+                focusOnShow: boolean;
+                trapping: boolean;
+                stopPopperMouseEvent: boolean;
+                pure: boolean;
+                triggerKeys: string[];
+                teleported: boolean;
+                rawContent: boolean;
+                persistent: boolean;
+                showArrow: boolean;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    default?(_: {}): any;
+                    content?(_: {}): any;
+                };
+            }) & import('vue').Plugin;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default _default;