import { Ref } from 'vue';
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<import('vue').ExtractPropTypes<{
    height: StringConstructor;
    src: StringConstructor;
    imageType: {
        type: StringConstructor;
        default: string;
    };
    accept: {
        type: StringConstructor;
        default: string;
    };
    tools: {
        type: StringConstructor;
        default: string;
    };
    preview: {
        type: BooleanConstructor;
        default: boolean;
    };
    previewWidth: {
        type: NumberConstructor;
        default: number;
    };
    toBlob: BooleanConstructor;
    options: import('vue').PropType<CropperOptions>;
    croppedOptions: import('vue').PropType<import('./types').CroppedOptions>;
    tooltip: {
        type: BooleanConstructor;
        default: boolean;
    };
    tooltipProps: import('vue').PropType<import('../ele-app/plus').EleTooltipProps>;
    beforeUploadClick: import('vue').PropType<import('./types').BeforeUploadClick>;
    responsive: {
        type: BooleanConstructor;
        default: null;
    };
    locale: import('vue').PropType<Partial<import('./types').CropperLocale>>;
}>, {
    imageRef: Ref<HTMLImageElement | null, HTMLImageElement | null>;
    previewRef: Ref<PreviewInstance, PreviewInstance>;
    isResponsive: import('vue').ComputedRef<boolean>;
    handleZoomIn: () => void;
    handleZoomOut: () => void;
    handleMoveLeft: () => void;
    handleMoveRight: () => void;
    handleMoveUp: () => void;
    handleMoveDown: () => void;
    handleRotateLeft: () => void;
    handleRotateRight: () => void;
    handleFlipX: () => void;
    handleFlipY: () => void;
    handleReset: () => void;
    handleUpload: ({ data, type }: {
        data: string;
        type: string;
    }) => void;
    handleOk: () => void;
}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
    done: (_result?: Blob | string | null) => boolean;
}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
    height: StringConstructor;
    src: StringConstructor;
    imageType: {
        type: StringConstructor;
        default: string;
    };
    accept: {
        type: StringConstructor;
        default: string;
    };
    tools: {
        type: StringConstructor;
        default: string;
    };
    preview: {
        type: BooleanConstructor;
        default: boolean;
    };
    previewWidth: {
        type: NumberConstructor;
        default: number;
    };
    toBlob: BooleanConstructor;
    options: import('vue').PropType<CropperOptions>;
    croppedOptions: import('vue').PropType<import('./types').CroppedOptions>;
    tooltip: {
        type: BooleanConstructor;
        default: boolean;
    };
    tooltipProps: import('vue').PropType<import('../ele-app/plus').EleTooltipProps>;
    beforeUploadClick: import('vue').PropType<import('./types').BeforeUploadClick>;
    responsive: {
        type: BooleanConstructor;
        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;
    imageType: string;
    accept: string;
    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;