import { CropperLocale } from '../ele-cropper/types';

declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
    modelValue: BooleanConstructor;
    modalProps: import('vue').PropType<Partial<Omit<import('../ele-app/plus').EleDialogProps, "modelValue">>>;
    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<import('../ele-cropper/types').CropperOptions>;
    croppedOptions: import('vue').PropType<import('../ele-cropper/types').CroppedOptions>;
    tooltip: {
        type: BooleanConstructor;
        default: boolean;
    };
    tooltipProps: import('vue').PropType<import('../ele-app/plus').EleTooltipProps>;
    beforeUploadClick: import('vue').PropType<import('../ele-cropper/types').BeforeUploadClick>;
    responsive: {
        type: BooleanConstructor;
        default: null;
    };
    locale: import('vue').PropType<Partial<CropperLocale>>;
}>, {
    lang: import('vue').ComputedRef<CropperLocale>;
    updateModelValue: (value: boolean) => void;
    handleDone: (result: Blob | string | null) => void;
}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
    done: (_result: Blob | string | null) => boolean;
    'update:modelValue': (_value: boolean) => boolean;
}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
    modelValue: BooleanConstructor;
    modalProps: import('vue').PropType<Partial<Omit<import('../ele-app/plus').EleDialogProps, "modelValue">>>;
    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<import('../ele-cropper/types').CropperOptions>;
    croppedOptions: import('vue').PropType<import('../ele-cropper/types').CroppedOptions>;
    tooltip: {
        type: BooleanConstructor;
        default: boolean;
    };
    tooltipProps: import('vue').PropType<import('../ele-app/plus').EleTooltipProps>;
    beforeUploadClick: import('vue').PropType<import('../ele-cropper/types').BeforeUploadClick>;
    responsive: {
        type: BooleanConstructor;
        default: null;
    };
    locale: import('vue').PropType<Partial<CropperLocale>>;
}>> & Readonly<{
    onDone?: ((_result: string | Blob | null) => any) | undefined;
    "onUpdate:modelValue"?: ((_value: boolean) => any) | undefined;
}>, {
    modelValue: boolean;
    tooltip: boolean;
    preview: boolean;
    responsive: boolean;
    imageType: string;
    accept: string;
    tools: string;
    previewWidth: number;
    toBlob: boolean;
}, {}, {
    EleDialog: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        appendToBody: {
            type: BooleanConstructor;
            default: boolean;
        };
        draggable: {
            type: BooleanConstructor;
            default: boolean;
        };
        moveOut: import('vue').PropType<import('../ele-dialog/types').MoveOut>;
        resizable: import('vue').PropType<import('../ele-dialog/types').Resizable>;
        position: import('vue').PropType<import('../ele-dialog/types').Position>;
        resetOnClose: {
            type: BooleanConstructor;
            default: boolean;
        };
        maxable: BooleanConstructor;
        multiple: BooleanConstructor;
        inner: BooleanConstructor;
        minWidth: {
            type: NumberConstructor;
            default: number;
        };
        minHeight: {
            type: NumberConstructor;
            default: number;
        };
        headerStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
        titleStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
        bodyStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
        footerStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
        closeBtnStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
        fullscreenBtnStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
        resizeIconStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
        responsive: {
            type: BooleanConstructor;
            default: null;
        };
        form: BooleanConstructor;
        closeOnClickModal: {
            type: BooleanConstructor;
            default: boolean;
        };
        appendTo: {
            readonly type: import('vue').PropType<string | HTMLElement>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "body";
        };
        beforeClose: {
            readonly type: import('vue').PropType<import('element-plus').DialogBeforeCloseFn>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        destroyOnClose: BooleanConstructor;
        closeOnPressEscape: {
            readonly type: import('vue').PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        lockScroll: {
            readonly type: import('vue').PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        modal: {
            readonly type: import('vue').PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        openDelay: {
            readonly type: import('vue').PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: 0;
        };
        closeDelay: {
            readonly type: import('vue').PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: 0;
        };
        top: {
            readonly type: import('vue').PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        modelValue: BooleanConstructor;
        modalClass: StringConstructor;
        headerClass: StringConstructor;
        bodyClass: StringConstructor;
        footerClass: StringConstructor;
        width: {
            readonly type: import('vue').PropType<string | number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        zIndex: {
            readonly type: import('vue').PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        trapFocus: BooleanConstructor;
        headerAriaLevel: {
            readonly type: import('vue').PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "2";
        };
        center: BooleanConstructor;
        alignCenter: BooleanConstructor;
        closeIcon: {
            readonly type: import('vue').PropType<string | import('vue').Component>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        overflow: BooleanConstructor;
        fullscreen: BooleanConstructor;
        showClose: {
            readonly type: import('vue').PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        title: {
            readonly type: import('vue').PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "";
        };
        ariaLevel: {
            readonly type: import('vue').PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "2";
        };
    }>, {
        dialogRef: import('vue').Ref<import('../ele-app/el').ElDialogInstance, import('../ele-app/el').ElDialogInstance>;
        isFullscreen: import('vue').Ref<boolean, boolean>;
        modalClass: import('vue').ComputedRef<string>;
        teleportTo: import('vue').ComputedRef<string | Element>;
        teleportDisabled: import('vue').ComputedRef<boolean>;
        handleHeaderMousedown: (e: MouseEvent) => void;
        handleHeaderTouchstart: (e: TouchEvent) => void;
        handleResizeMousedown: (e: MouseEvent) => void;
        handleResizeTouchstart: (e: TouchEvent) => void;
        updateModelValue: (modelValue: boolean) => void;
        toggleFullscreen: (fullscreen?: boolean) => void;
        handleOpen: () => void;
        handleOpened: () => void;
        handleClose: () => void;
        handleClosed: () => void;
        handleOpenAutoFocus: () => void;
        handleCloseAutoFocus: () => void;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
        'update:fullscreen': (_fullscreen: boolean) => boolean;
        open: () => boolean;
        opened: () => boolean;
        close: () => boolean;
        closed: () => boolean;
        "update:modelValue": (value: boolean) => boolean;
        openAutoFocus: () => boolean;
        closeAutoFocus: () => boolean;
    }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        appendToBody: {
            type: BooleanConstructor;
            default: boolean;
        };
        draggable: {
            type: BooleanConstructor;
            default: boolean;
        };
        moveOut: import('vue').PropType<import('../ele-dialog/types').MoveOut>;
        resizable: import('vue').PropType<import('../ele-dialog/types').Resizable>;
        position: import('vue').PropType<import('../ele-dialog/types').Position>;
        resetOnClose: {
            type: BooleanConstructor;
            default: boolean;
        };
        maxable: BooleanConstructor;
        multiple: BooleanConstructor;
        inner: BooleanConstructor;
        minWidth: {
            type: NumberConstructor;
            default: number;
        };
        minHeight: {
            type: NumberConstructor;
            default: number;
        };
        headerStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
        titleStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
        bodyStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
        footerStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
        closeBtnStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
        fullscreenBtnStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
        resizeIconStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
        responsive: {
            type: BooleanConstructor;
            default: null;
        };
        form: BooleanConstructor;
        closeOnClickModal: {
            type: BooleanConstructor;
            default: boolean;
        };
        appendTo: {
            readonly type: import('vue').PropType<string | HTMLElement>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "body";
        };
        beforeClose: {
            readonly type: import('vue').PropType<import('element-plus').DialogBeforeCloseFn>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        destroyOnClose: BooleanConstructor;
        closeOnPressEscape: {
            readonly type: import('vue').PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        lockScroll: {
            readonly type: import('vue').PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        modal: {
            readonly type: import('vue').PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        openDelay: {
            readonly type: import('vue').PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: 0;
        };
        closeDelay: {
            readonly type: import('vue').PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: 0;
        };
        top: {
            readonly type: import('vue').PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        modelValue: BooleanConstructor;
        modalClass: StringConstructor;
        headerClass: StringConstructor;
        bodyClass: StringConstructor;
        footerClass: StringConstructor;
        width: {
            readonly type: import('vue').PropType<string | number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        zIndex: {
            readonly type: import('vue').PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        trapFocus: BooleanConstructor;
        headerAriaLevel: {
            readonly type: import('vue').PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "2";
        };
        center: BooleanConstructor;
        alignCenter: BooleanConstructor;
        closeIcon: {
            readonly type: import('vue').PropType<string | import('vue').Component>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        overflow: BooleanConstructor;
        fullscreen: BooleanConstructor;
        showClose: {
            readonly type: import('vue').PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        title: {
            readonly type: import('vue').PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "";
        };
        ariaLevel: {
            readonly type: import('vue').PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "2";
        };
    }>> & Readonly<{
        onClose?: (() => any) | undefined;
        onOpen?: (() => any) | undefined;
        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
        onClosed?: (() => any) | undefined;
        "onUpdate:fullscreen"?: ((_fullscreen: boolean) => any) | undefined;
        onOpened?: (() => any) | undefined;
        onOpenAutoFocus?: (() => any) | undefined;
        onCloseAutoFocus?: (() => any) | undefined;
    }>, {
        title: string;
        center: boolean;
        modelValue: boolean;
        appendTo: string | HTMLElement;
        appendToBody: boolean;
        destroyOnClose: boolean;
        closeOnClickModal: boolean;
        closeOnPressEscape: boolean;
        lockScroll: boolean;
        modal: boolean;
        openDelay: number;
        closeDelay: number;
        trapFocus: boolean;
        headerAriaLevel: string;
        alignCenter: boolean;
        draggable: boolean;
        overflow: boolean;
        fullscreen: boolean;
        showClose: boolean;
        ariaLevel: string;
        form: boolean;
        minWidth: number;
        minHeight: number;
        multiple: boolean;
        responsive: boolean;
        resetOnClose: boolean;
        maxable: boolean;
        inner: boolean;
    }, {}, {
        ElDialog: {
            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                readonly appendToBody: BooleanConstructor;
                readonly appendTo: {
                    readonly type: import('vue').PropType<string | HTMLElement>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "body";
                };
                readonly beforeClose: {
                    readonly type: import('vue').PropType<import('element-plus').DialogBeforeCloseFn>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly destroyOnClose: BooleanConstructor;
                readonly closeOnClickModal: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                readonly closeOnPressEscape: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                readonly lockScroll: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                readonly modal: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                readonly openDelay: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 0;
                };
                readonly closeDelay: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 0;
                };
                readonly top: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly modelValue: BooleanConstructor;
                readonly modalClass: StringConstructor;
                readonly headerClass: StringConstructor;
                readonly bodyClass: StringConstructor;
                readonly footerClass: StringConstructor;
                readonly width: {
                    readonly type: import('vue').PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly zIndex: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly trapFocus: BooleanConstructor;
                readonly headerAriaLevel: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "2";
                };
                readonly center: BooleanConstructor;
                readonly alignCenter: BooleanConstructor;
                readonly closeIcon: {
                    readonly type: import('vue').PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly draggable: BooleanConstructor;
                readonly overflow: BooleanConstructor;
                readonly fullscreen: BooleanConstructor;
                readonly showClose: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                readonly title: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly ariaLevel: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "2";
                };
            }>> & {
                "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
                onOpen?: (() => any) | undefined;
                onClose?: (() => any) | undefined;
                onOpened?: (() => any) | undefined;
                onClosed?: (() => any) | undefined;
                onOpenAutoFocus?: (() => any) | undefined;
                onCloseAutoFocus?: (() => any) | undefined;
            }, {
                visible: import('vue').Ref<boolean>;
                dialogContentRef: import('vue').Ref<any>;
                resetPosition: () => void;
                handleClose: () => void;
            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                open: () => void;
                "update:modelValue": (value: boolean) => void;
                close: () => void;
                opened: () => void;
                closed: () => void;
                openAutoFocus: () => void;
                closeAutoFocus: () => void;
            }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                readonly title: string;
                readonly center: boolean;
                readonly overflow: boolean;
                readonly modelValue: boolean;
                readonly ariaLevel: string;
                readonly appendTo: string | HTMLElement;
                readonly showClose: boolean;
                readonly alignCenter: boolean;
                readonly draggable: boolean;
                readonly fullscreen: boolean;
                readonly closeOnClickModal: boolean;
                readonly closeOnPressEscape: boolean;
                readonly lockScroll: boolean;
                readonly modal: boolean;
                readonly openDelay: number;
                readonly closeDelay: number;
                readonly headerAriaLevel: string;
                readonly appendToBody: boolean;
                readonly destroyOnClose: boolean;
                readonly trapFocus: boolean;
            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import('vue').ExtractPropTypes<{
                readonly appendToBody: BooleanConstructor;
                readonly appendTo: {
                    readonly type: import('vue').PropType<string | HTMLElement>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "body";
                };
                readonly beforeClose: {
                    readonly type: import('vue').PropType<import('element-plus').DialogBeforeCloseFn>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly destroyOnClose: BooleanConstructor;
                readonly closeOnClickModal: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                readonly closeOnPressEscape: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                readonly lockScroll: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                readonly modal: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                readonly openDelay: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 0;
                };
                readonly closeDelay: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 0;
                };
                readonly top: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly modelValue: BooleanConstructor;
                readonly modalClass: StringConstructor;
                readonly headerClass: StringConstructor;
                readonly bodyClass: StringConstructor;
                readonly footerClass: StringConstructor;
                readonly width: {
                    readonly type: import('vue').PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly zIndex: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly trapFocus: BooleanConstructor;
                readonly headerAriaLevel: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "2";
                };
                readonly center: BooleanConstructor;
                readonly alignCenter: BooleanConstructor;
                readonly closeIcon: {
                    readonly type: import('vue').PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly draggable: BooleanConstructor;
                readonly overflow: BooleanConstructor;
                readonly fullscreen: BooleanConstructor;
                readonly showClose: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                readonly title: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly ariaLevel: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "2";
                };
            }>> & {
                "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
                onOpen?: (() => any) | undefined;
                onClose?: (() => any) | undefined;
                onOpened?: (() => any) | undefined;
                onClosed?: (() => any) | undefined;
                onOpenAutoFocus?: (() => any) | undefined;
                onCloseAutoFocus?: (() => any) | undefined;
            }, {
                visible: import('vue').Ref<boolean>;
                dialogContentRef: import('vue').Ref<any>;
                resetPosition: () => void;
                handleClose: () => void;
            }, {}, {}, {}, {
                readonly title: string;
                readonly center: boolean;
                readonly overflow: boolean;
                readonly modelValue: boolean;
                readonly ariaLevel: string;
                readonly appendTo: string | HTMLElement;
                readonly showClose: boolean;
                readonly alignCenter: boolean;
                readonly draggable: boolean;
                readonly fullscreen: boolean;
                readonly closeOnClickModal: boolean;
                readonly closeOnPressEscape: boolean;
                readonly lockScroll: boolean;
                readonly modal: boolean;
                readonly openDelay: number;
                readonly closeDelay: number;
                readonly headerAriaLevel: string;
                readonly appendToBody: boolean;
                readonly destroyOnClose: boolean;
                readonly trapFocus: boolean;
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
            readonly appendToBody: BooleanConstructor;
            readonly appendTo: {
                readonly type: import('vue').PropType<string | HTMLElement>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "body";
            };
            readonly beforeClose: {
                readonly type: import('vue').PropType<import('element-plus').DialogBeforeCloseFn>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly destroyOnClose: BooleanConstructor;
            readonly closeOnClickModal: {
                readonly type: import('vue').PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            readonly closeOnPressEscape: {
                readonly type: import('vue').PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            readonly lockScroll: {
                readonly type: import('vue').PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            readonly modal: {
                readonly type: import('vue').PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            readonly openDelay: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 0;
            };
            readonly closeDelay: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 0;
            };
            readonly top: {
                readonly type: import('vue').PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly modelValue: BooleanConstructor;
            readonly modalClass: StringConstructor;
            readonly headerClass: StringConstructor;
            readonly bodyClass: StringConstructor;
            readonly footerClass: StringConstructor;
            readonly width: {
                readonly type: import('vue').PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly zIndex: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly trapFocus: BooleanConstructor;
            readonly headerAriaLevel: {
                readonly type: import('vue').PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "2";
            };
            readonly center: BooleanConstructor;
            readonly alignCenter: BooleanConstructor;
            readonly closeIcon: {
                readonly type: import('vue').PropType<string | import('vue').Component>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly draggable: BooleanConstructor;
            readonly overflow: BooleanConstructor;
            readonly fullscreen: BooleanConstructor;
            readonly showClose: {
                readonly type: import('vue').PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            readonly title: {
                readonly type: import('vue').PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            readonly ariaLevel: {
                readonly type: import('vue').PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "2";
            };
        }>> & {
            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
            onOpen?: (() => any) | undefined;
            onClose?: (() => any) | undefined;
            onOpened?: (() => any) | undefined;
            onClosed?: (() => any) | undefined;
            onOpenAutoFocus?: (() => any) | undefined;
            onCloseAutoFocus?: (() => any) | undefined;
        }, {
            visible: import('vue').Ref<boolean>;
            dialogContentRef: import('vue').Ref<any>;
            resetPosition: () => void;
            handleClose: () => void;
        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
            open: () => void;
            "update:modelValue": (value: boolean) => void;
            close: () => void;
            opened: () => void;
            closed: () => void;
            openAutoFocus: () => void;
            closeAutoFocus: () => void;
        }, string, {
            readonly title: string;
            readonly center: boolean;
            readonly overflow: boolean;
            readonly modelValue: boolean;
            readonly ariaLevel: string;
            readonly appendTo: string | HTMLElement;
            readonly showClose: boolean;
            readonly alignCenter: boolean;
            readonly draggable: boolean;
            readonly fullscreen: boolean;
            readonly closeOnClickModal: boolean;
            readonly closeOnPressEscape: boolean;
            readonly lockScroll: boolean;
            readonly modal: boolean;
            readonly openDelay: number;
            readonly closeDelay: number;
            readonly headerAriaLevel: string;
            readonly appendToBody: boolean;
            readonly destroyOnClose: boolean;
            readonly trapFocus: boolean;
        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
            $slots: {
                header?(_: {
                    close: () => void;
                    titleId: string;
                    titleClass: string;
                }): any;
                title?(_: {}): any;
                default?(_: {}): any;
                footer?(_: {}): any;
            };
        }) & import('vue').Plugin;
        ElIcon: {
            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                readonly size: {
                    readonly type: import('vue').PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly color: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {}, 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<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly color: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {}, {}, {}, {}, {}>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
            readonly size: {
                readonly type: import('vue').PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly color: {
                readonly type: import('vue').PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
        }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {}, {}, 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;
        CloseOutlined: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        CompressOutlined: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        ExpandOutlined: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        ResizeOutlined: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        ReceiverView: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
            wrapPosition: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>, {
            authenticated: import('vue').Ref<boolean, boolean>;
            watermark: string[];
        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
            wrapPosition: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{}>, {
            wrapPosition: boolean;
        }, {}, {
            EleWatermark: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
                width: NumberConstructor;
                height: NumberConstructor;
                rotate: NumberConstructor;
                zIndex: NumberConstructor;
                image: StringConstructor;
                content: import('vue').PropType<string | string[]>;
                font: import('vue').PropType<import('../ele-watermark/types').WatermarkFont>;
                gap: import('vue').PropType<import('../ele-watermark/types').WatermarkGap>;
                offset: import('vue').PropType<import('../ele-watermark/types').WatermarkOffset>;
                lineGap: {
                    type: NumberConstructor;
                    default: number;
                };
                customStyle: import('vue').PropType<Exclude<import('../ele-app/types').StyleValue, string>>;
                fixed: BooleanConstructor;
                wrapPosition: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disabled: BooleanConstructor;
            }>, {
                rootKey: import('vue').Ref<number, number>;
                rootRef: import('vue').Ref<HTMLDivElement | null, HTMLDivElement | null>;
                imgRef: import('vue').Ref<HTMLDivElement | null, HTMLDivElement | null>;
                imgStyle: import('vue').Ref<Partial<import('vue').CSSProperties>, Partial<import('vue').CSSProperties>>;
            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
                width: NumberConstructor;
                height: NumberConstructor;
                rotate: NumberConstructor;
                zIndex: NumberConstructor;
                image: StringConstructor;
                content: import('vue').PropType<string | string[]>;
                font: import('vue').PropType<import('../ele-watermark/types').WatermarkFont>;
                gap: import('vue').PropType<import('../ele-watermark/types').WatermarkGap>;
                offset: import('vue').PropType<import('../ele-watermark/types').WatermarkOffset>;
                lineGap: {
                    type: NumberConstructor;
                    default: number;
                };
                customStyle: import('vue').PropType<Exclude<import('../ele-app/types').StyleValue, string>>;
                fixed: BooleanConstructor;
                wrapPosition: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disabled: BooleanConstructor;
            }>> & Readonly<{}>, {
                disabled: boolean;
                fixed: boolean;
                lineGap: number;
                wrapPosition: boolean;
            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    EleCropper: 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<import('../ele-cropper/types').CropperOptions>;
        croppedOptions: import('vue').PropType<import('../ele-cropper/types').CroppedOptions>;
        tooltip: {
            type: BooleanConstructor;
            default: boolean;
        };
        tooltipProps: import('vue').PropType<import('../ele-app/plus').EleTooltipProps>;
        beforeUploadClick: import('vue').PropType<import('../ele-cropper/types').BeforeUploadClick>;
        responsive: {
            type: BooleanConstructor;
            default: null;
        };
        locale: import('vue').PropType<Partial<CropperLocale>>;
    }>, {
        imageRef: import('vue').Ref<HTMLImageElement | null, HTMLImageElement | null>;
        previewRef: import('vue').Ref<import('../ele-cropper/index').PreviewInstance, import('../ele-cropper/index').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<import('../ele-cropper/types').CropperOptions>;
        croppedOptions: import('vue').PropType<import('../ele-cropper/types').CroppedOptions>;
        tooltip: {
            type: BooleanConstructor;
            default: boolean;
        };
        tooltipProps: import('vue').PropType<import('../ele-app/plus').EleTooltipProps>;
        beforeUploadClick: import('vue').PropType<import('../ele-cropper/types').BeforeUploadClick>;
        responsive: {
            type: BooleanConstructor;
            default: null;
        };
        locale: import('vue').PropType<Partial<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: import('vue').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('../ele-cropper/types').BeforeUploadClick>;
            locale: import('vue').PropType<Partial<CropperLocale>>;
        }>, {
            lang: import('vue').ComputedRef<CropperLocale>;
            tooltipRef: import('vue').Ref<import('../ele-app/plus').EleTooltipInstance, import('../ele-app/plus').EleTooltipInstance>;
            groups: import('vue').ShallowRef<import('../ele-cropper/types').ToolGroup[], import('../ele-cropper/types').ToolGroup[]>;
            tooltipContent: import('vue').Ref<string, string>;
            virtualRef: import('vue').Ref<any, any>;
            handleUpload: (file: File) => boolean;
            handleClick: (name: Omit<import('../ele-cropper/types').ToolName, "upload">) => void;
            handleItemHover: (item: import('../ele-cropper/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('../ele-cropper/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('../ele-cropper/types').BeforeUploadClick>;
            locale: import('vue').PropType<Partial<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('../ele-cropper/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: import('vue').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: import('vue').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: import('vue').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: import('vue').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: import('vue').Ref<import('element-plus').PopperInstance | undefined>;
                        contentRef: import('vue').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: import('vue').Ref<import('element-plus').PopperInstance | undefined>;
                        contentRef: import('vue').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: import('vue').Ref<import('element-plus').PopperInstance | undefined>;
                    contentRef: import('vue').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>;
}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
export default _default;