import { UploadItem, UploadLocale, ImageObjectUrl } from './types';

declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
    modelValue: import('vue').PropType<UploadItem[]>;
    readonly: BooleanConstructor;
    disabled: BooleanConstructor;
    preview: {
        type: BooleanConstructor;
        default: boolean;
    };
    limit: NumberConstructor;
    multiple: BooleanConstructor;
    drag: BooleanConstructor;
    accept: {
        type: StringConstructor;
        default: string;
    };
    itemStyle: import('vue').PropType<import('../ele-app/types').StyleValue | false>;
    buttonStyle: {
        type: import('vue').PropType<import('../ele-app/types').StyleValue | false>;
        default: null;
    };
    sortable: {
        type: import('vue').PropType<boolean | Record<keyof any, any>>;
        default: boolean;
    };
    imageProps: import('vue').PropType<import('../ele-app/el').ElImageProps>;
    progressProps: import('vue').PropType<import('../ele-app/el').ElProgressProps>;
    previewProps: import('vue').PropType<import('../ele-app/plus').EleImageViewerProps>;
    tools: BooleanConstructor;
    listType: import('vue').PropType<import('./types').ListType>;
    beforeUploadClick: import('vue').PropType<import('./types').BeforeUploadClick>;
    beforeItemEdit: import('vue').PropType<import('./types').BeforeItemEdit>;
    locale: import('vue').PropType<Partial<UploadLocale>>;
}>, {
    ownSlots: string[];
    lang: import('vue').ComputedRef<UploadLocale>;
    previewVisible: import('vue').Ref<boolean, boolean>;
    previewImages: import('vue').Ref<string[], string[]>;
    previewCurrentIndex: import('vue').Ref<number, number>;
    imageObjectUrls: import('vue').Ref<{
        file: {
            readonly lastModified: number;
            readonly name: string;
            readonly webkitRelativePath: string;
            readonly size: number;
            readonly type: string;
            arrayBuffer: () => Promise<ArrayBuffer>;
            bytes: () => Promise<Uint8Array>;
            slice: (start?: number, end?: number, contentType?: string) => Blob;
            stream: () => ReadableStream<Uint8Array>;
            text: () => Promise<string>;
        };
        url: string;
    }[], ImageObjectUrl[] | {
        file: {
            readonly lastModified: number;
            readonly name: string;
            readonly webkitRelativePath: string;
            readonly size: number;
            readonly type: string;
            arrayBuffer: () => Promise<ArrayBuffer>;
            bytes: () => Promise<Uint8Array>;
            slice: (start?: number, end?: number, contentType?: string) => Blob;
            stream: () => ReadableStream<Uint8Array>;
            text: () => Promise<string>;
        };
        url: string;
    }[]>;
    uploadInputRef: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
    uploadEnable: import('vue').ComputedRef<boolean>;
    updateModelValue: (value: UploadItem[]) => void;
    handleUpload: (file: File) => boolean;
    handleItemClick: (item: UploadItem) => void;
    handleItemRemove: (item: UploadItem) => void;
    handleItemEdit: (item: UploadItem) => void;
    handleItemPreview: (item: UploadItem) => void;
    handleItemRetry: (item: UploadItem) => void;
    handleInputChange: (e: Event) => void;
    handleUploadClick: (e: MouseEvent) => void;
    openImagePreview: (urls: string[], index: number) => void;
    isImage: (url?: string) => boolean | "" | undefined;
}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
    'update:modelValue': (_value: UploadItem[]) => boolean;
    itemClick: (_item: UploadItem) => boolean;
    upload: (_item: UploadItem) => boolean;
    remove: (_item: UploadItem) => boolean;
    retry: (_item: UploadItem) => boolean;
    editUpload: (_result: import('./types').EditUploadResult) => boolean;
    preview: (_item: UploadItem) => boolean;
}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
    modelValue: import('vue').PropType<UploadItem[]>;
    readonly: BooleanConstructor;
    disabled: BooleanConstructor;
    preview: {
        type: BooleanConstructor;
        default: boolean;
    };
    limit: NumberConstructor;
    multiple: BooleanConstructor;
    drag: BooleanConstructor;
    accept: {
        type: StringConstructor;
        default: string;
    };
    itemStyle: import('vue').PropType<import('../ele-app/types').StyleValue | false>;
    buttonStyle: {
        type: import('vue').PropType<import('../ele-app/types').StyleValue | false>;
        default: null;
    };
    sortable: {
        type: import('vue').PropType<boolean | Record<keyof any, any>>;
        default: boolean;
    };
    imageProps: import('vue').PropType<import('../ele-app/el').ElImageProps>;
    progressProps: import('vue').PropType<import('../ele-app/el').ElProgressProps>;
    previewProps: import('vue').PropType<import('../ele-app/plus').EleImageViewerProps>;
    tools: BooleanConstructor;
    listType: import('vue').PropType<import('./types').ListType>;
    beforeUploadClick: import('vue').PropType<import('./types').BeforeUploadClick>;
    beforeItemEdit: import('vue').PropType<import('./types').BeforeItemEdit>;
    locale: import('vue').PropType<Partial<UploadLocale>>;
}>> & Readonly<{
    onItemClick?: ((_item: UploadItem) => any) | undefined;
    "onUpdate:modelValue"?: ((_value: UploadItem[]) => any) | undefined;
    onRemove?: ((_item: UploadItem) => any) | undefined;
    onUpload?: ((_item: UploadItem) => any) | undefined;
    onPreview?: ((_item: UploadItem) => any) | undefined;
    onRetry?: ((_item: UploadItem) => any) | undefined;
    onEditUpload?: ((_result: import('./types').EditUploadResult) => any) | undefined;
}>, {
    drag: boolean;
    disabled: boolean;
    readonly: boolean;
    sortable: boolean | Record<string | number | symbol, any>;
    multiple: boolean;
    preview: boolean;
    accept: string;
    tools: boolean;
    buttonStyle: false | Partial<import('vue').CSSProperties>;
}, {}, {
    VueDraggable: import('vue').DefineComponent<{
        list: {
            type: ArrayConstructor;
            required: boolean;
            default: any;
        };
        modelValue: {
            type: ArrayConstructor;
            required: boolean;
            default: any;
        };
        itemKey: {
            type: (FunctionConstructor | StringConstructor)[];
            required: boolean;
        };
        clone: {
            type: FunctionConstructor;
            default: (original: any) => any;
        };
        tag: {
            type: StringConstructor;
            default: string;
        };
        move: {
            type: FunctionConstructor;
            default: any;
        };
        componentData: {
            type: ObjectConstructor;
            required: boolean;
            default: any;
        };
    }, unknown, {
        error: boolean;
    }, {
        realList(): any;
        getKey(): any;
    }, {
        getUnderlyingVm(domElement: any): any;
        getUnderlyingPotencialDraggableComponent(htmElement: any): any;
        emitChanges(evt: any): void;
        alterList(onList: any): void;
        spliceList(): void;
        updatePosition(oldIndex: any, newIndex: any): void;
        getRelatedContextFromMoveEvent({ to, related }: {
            to: any;
            related: any;
        }): any;
        getVmIndexFromDomIndex(domIndex: any): any;
        onDragStart(evt: any): void;
        onDragAdd(evt: any): void;
        onDragRemove(evt: any): void;
        onDragUpdate(evt: any): void;
        computeFutureIndex(relatedContext: any, evt: any): any;
        onDragMove(evt: any, originalEvent: any): any;
        onDragEnd(): void;
    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, any[], any, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, Readonly<{
        move: Function;
        tag: string;
        clone: Function;
        list: unknown[];
        modelValue: unknown[];
        componentData: Record<string, any>;
    } & {
        itemKey?: string | Function;
    }>, {
        move: Function;
        tag: string;
        clone: Function;
        list: unknown[];
        modelValue: unknown[];
        componentData: Record<string, any>;
    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, 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<"picture" | "text" | "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: "picture" | "text" | "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<"picture" | "text" | "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: "picture" | "text" | "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<"picture" | "text" | "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: "picture" | "text" | "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;
    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;
    PlusOutlined: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    EleImageViewer: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        teleported: {
            type: BooleanConstructor;
            default: boolean;
        };
        modelValue: BooleanConstructor;
        customClass: StringConstructor;
        customStyle: ObjectConstructor;
        transitionName: {
            type: StringConstructor;
            default: string;
        };
        keepAlive: BooleanConstructor;
        urlList: {
            readonly type: import('vue').PropType<string[]>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => [];
        };
        zIndex: {
            readonly type: import('vue').PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        initialIndex: {
            readonly type: import('vue').PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: 0;
        };
        infinite: {
            readonly type: import('vue').PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        hideOnClickModal: BooleanConstructor;
        closeOnPressEscape: {
            readonly type: import('vue').PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        zoomRate: {
            readonly type: import('vue').PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: 1.2;
        };
        minScale: {
            readonly type: import('vue').PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: 0.2;
        };
        maxScale: {
            readonly type: import('vue').PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: 7;
        };
        showProgress: {
            readonly type: import('vue').PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: false;
        };
        crossorigin: {
            readonly type: import('vue').PropType<"" | "anonymous" | "use-credentials">;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
    }>, {
        imageViewerRef: import('vue').Ref<import('../ele-app/el').ElImageViewerInstance, import('../ele-app/el').ElImageViewerInstance>;
        viewerProps: import('vue').ComputedRef<import('../ele-app/types').Mutable<Omit<import('@vue/shared').LooseRequired<Readonly<import('vue').ExtractPropTypes<{
            teleported: {
                type: BooleanConstructor;
                default: boolean;
            };
            modelValue: BooleanConstructor;
            customClass: StringConstructor;
            customStyle: ObjectConstructor;
            transitionName: {
                type: StringConstructor;
                default: string;
            };
            keepAlive: BooleanConstructor;
            urlList: {
                readonly type: import('vue').PropType<string[]>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: () => [];
            };
            zIndex: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            initialIndex: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 0;
            };
            infinite: {
                readonly type: import('vue').PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            hideOnClickModal: BooleanConstructor;
            closeOnPressEscape: {
                readonly type: import('vue').PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            zoomRate: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 1.2;
            };
            minScale: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 0.2;
            };
            maxScale: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 7;
            };
            showProgress: {
                readonly type: import('vue').PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: false;
            };
            crossorigin: {
                readonly type: import('vue').PropType<"" | "anonymous" | "use-credentials">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
        }>> & Readonly<{
            onClose?: (() => any) | undefined;
            onRotate?: ((_deg: number) => any) | undefined;
            onSwitch?: ((_index: number) => any) | undefined;
            "onUpdate:modelValue"?: ((_value?: boolean | undefined) => any) | undefined;
        }> & {}>, "modelValue" | "customClass" | "transitionName" | "customStyle" | "keepAlive">>>;
        handleClose: () => void;
        handleSwitch: (index: number) => void;
        handleRotate: (deg: number) => void;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
        'update:modelValue': (_value?: boolean) => boolean;
        close: () => boolean;
        switch: (_index: number) => boolean;
        rotate: (_deg: number) => boolean;
    }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        teleported: {
            type: BooleanConstructor;
            default: boolean;
        };
        modelValue: BooleanConstructor;
        customClass: StringConstructor;
        customStyle: ObjectConstructor;
        transitionName: {
            type: StringConstructor;
            default: string;
        };
        keepAlive: BooleanConstructor;
        urlList: {
            readonly type: import('vue').PropType<string[]>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => [];
        };
        zIndex: {
            readonly type: import('vue').PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        initialIndex: {
            readonly type: import('vue').PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: 0;
        };
        infinite: {
            readonly type: import('vue').PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        hideOnClickModal: BooleanConstructor;
        closeOnPressEscape: {
            readonly type: import('vue').PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        zoomRate: {
            readonly type: import('vue').PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: 1.2;
        };
        minScale: {
            readonly type: import('vue').PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: 0.2;
        };
        maxScale: {
            readonly type: import('vue').PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: 7;
        };
        showProgress: {
            readonly type: import('vue').PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: false;
        };
        crossorigin: {
            readonly type: import('vue').PropType<"" | "anonymous" | "use-credentials">;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
    }>> & Readonly<{
        onClose?: (() => any) | undefined;
        onRotate?: ((_deg: number) => any) | undefined;
        onSwitch?: ((_index: number) => any) | undefined;
        "onUpdate:modelValue"?: ((_value?: boolean | undefined) => any) | undefined;
    }>, {
        modelValue: boolean;
        teleported: boolean;
        closeOnPressEscape: boolean;
        hideOnClickModal: boolean;
        initialIndex: number;
        infinite: boolean;
        zoomRate: number;
        minScale: number;
        maxScale: number;
        showProgress: boolean;
        urlList: string[];
        transitionName: string;
        keepAlive: boolean;
    }, {}, {
        ElImageViewer: {
            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                readonly urlList: {
                    readonly type: import('vue').PropType<string[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => [];
                };
                readonly zIndex: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly initialIndex: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 0;
                };
                readonly infinite: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                readonly hideOnClickModal: BooleanConstructor;
                readonly teleported: BooleanConstructor;
                readonly closeOnPressEscape: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                readonly zoomRate: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 1.2;
                };
                readonly minScale: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 0.2;
                };
                readonly maxScale: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 7;
                };
                readonly showProgress: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: false;
                };
                readonly crossorigin: {
                    readonly type: import('vue').PropType<"" | "anonymous" | "use-credentials">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>> & {
                onClose?: (() => any) | undefined;
                onSwitch?: ((index: number) => any) | undefined;
                onRotate?: ((deg: number) => any) | undefined;
            }, {
                setActiveItem: (index: number) => void;
            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                switch: (index: number) => void;
                rotate: (deg: number) => void;
                close: () => void;
            }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                readonly infinite: boolean;
                readonly teleported: boolean;
                readonly initialIndex: number;
                readonly closeOnPressEscape: boolean;
                readonly urlList: string[];
                readonly zoomRate: number;
                readonly minScale: number;
                readonly maxScale: number;
                readonly showProgress: boolean;
                readonly hideOnClickModal: boolean;
            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import('vue').ExtractPropTypes<{
                readonly urlList: {
                    readonly type: import('vue').PropType<string[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => [];
                };
                readonly zIndex: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly initialIndex: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 0;
                };
                readonly infinite: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                readonly hideOnClickModal: BooleanConstructor;
                readonly teleported: BooleanConstructor;
                readonly closeOnPressEscape: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                readonly zoomRate: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 1.2;
                };
                readonly minScale: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 0.2;
                };
                readonly maxScale: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 7;
                };
                readonly showProgress: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: false;
                };
                readonly crossorigin: {
                    readonly type: import('vue').PropType<"" | "anonymous" | "use-credentials">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>> & {
                onClose?: (() => any) | undefined;
                onSwitch?: ((index: number) => any) | undefined;
                onRotate?: ((deg: number) => any) | undefined;
            }, {
                setActiveItem: (index: number) => void;
            }, {}, {}, {}, {
                readonly infinite: boolean;
                readonly teleported: boolean;
                readonly initialIndex: number;
                readonly closeOnPressEscape: boolean;
                readonly urlList: string[];
                readonly zoomRate: number;
                readonly minScale: number;
                readonly maxScale: number;
                readonly showProgress: boolean;
                readonly hideOnClickModal: boolean;
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
            readonly urlList: {
                readonly type: import('vue').PropType<string[]>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: () => [];
            };
            readonly zIndex: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly initialIndex: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 0;
            };
            readonly infinite: {
                readonly type: import('vue').PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            readonly hideOnClickModal: BooleanConstructor;
            readonly teleported: BooleanConstructor;
            readonly closeOnPressEscape: {
                readonly type: import('vue').PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            readonly zoomRate: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 1.2;
            };
            readonly minScale: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 0.2;
            };
            readonly maxScale: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 7;
            };
            readonly showProgress: {
                readonly type: import('vue').PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: false;
            };
            readonly crossorigin: {
                readonly type: import('vue').PropType<"" | "anonymous" | "use-credentials">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
        }>> & {
            onClose?: (() => any) | undefined;
            onSwitch?: ((index: number) => any) | undefined;
            onRotate?: ((deg: number) => any) | undefined;
        }, {
            setActiveItem: (index: number) => void;
        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
            switch: (index: number) => void;
            rotate: (deg: number) => void;
            close: () => void;
        }, string, {
            readonly infinite: boolean;
            readonly teleported: boolean;
            readonly initialIndex: number;
            readonly closeOnPressEscape: boolean;
            readonly urlList: string[];
            readonly zoomRate: number;
            readonly minScale: number;
            readonly maxScale: number;
            readonly showProgress: boolean;
            readonly hideOnClickModal: boolean;
        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
            $slots: {
                progress?(_: {
                    activeIndex: number;
                    total: number;
                }): any;
                toolbar?(_: {
                    actions: (action: import('element-plus').ImageViewerAction, options?: {}) => void;
                    prev: () => void;
                    next: () => void;
                    reset: () => void;
                    activeIndex: number;
                    setActiveItem: (index: number) => void;
                }): any;
                default?(_: {}): any;
            };
        }) & import('vue').Plugin;
    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    ListItem: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        item: {
            type: import('vue').PropType<UploadItem>;
            required: true;
        };
        readonly: BooleanConstructor;
        disabled: BooleanConstructor;
        sortable: BooleanConstructor;
        imageProps: import('vue').PropType<import('../ele-app/el').ElImageProps>;
        progressProps: import('vue').PropType<import('../ele-app/el').ElProgressProps>;
        imageObjectUrls: import('vue').PropType<ImageObjectUrl[]>;
        tools: BooleanConstructor;
        listType: import('vue').PropType<import('./types').ListType>;
        locale: {
            type: import('vue').PropType<Partial<UploadLocale>>;
            required: true;
        };
    }>, {
        imageUrl: import('vue').ComputedRef<string | undefined>;
        uploadProgress: import('vue').ComputedRef<number>;
        handleItemClick: () => void;
        handleRemove: () => void;
        handleEdit: () => void;
        handlePreview: () => void;
        handleRetry: () => void;
        isImage: (url?: string) => boolean | "" | undefined;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
        itemClick: (_item: UploadItem) => true;
        remove: (_item: UploadItem) => true;
        edit: (_item: UploadItem) => true;
        preview: (_item: UploadItem) => true;
        retry: (_item: UploadItem) => true;
    }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        item: {
            type: import('vue').PropType<UploadItem>;
            required: true;
        };
        readonly: BooleanConstructor;
        disabled: BooleanConstructor;
        sortable: BooleanConstructor;
        imageProps: import('vue').PropType<import('../ele-app/el').ElImageProps>;
        progressProps: import('vue').PropType<import('../ele-app/el').ElProgressProps>;
        imageObjectUrls: import('vue').PropType<ImageObjectUrl[]>;
        tools: BooleanConstructor;
        listType: import('vue').PropType<import('./types').ListType>;
        locale: {
            type: import('vue').PropType<Partial<UploadLocale>>;
            required: true;
        };
    }>> & Readonly<{
        onItemClick?: ((_item: UploadItem) => any) | undefined;
        onEdit?: ((_item: UploadItem) => any) | undefined;
        onRemove?: ((_item: UploadItem) => any) | undefined;
        onPreview?: ((_item: UploadItem) => any) | undefined;
        onRetry?: ((_item: UploadItem) => any) | undefined;
    }>, {
        disabled: boolean;
        readonly: boolean;
        sortable: boolean;
        tools: boolean;
    }, {}, {
        CloseOutlined: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        EyeOutlined: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        EditOutlined: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        SyncOutlined: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        FileOutlined: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        ElImage: {
            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                readonly hideOnClickModal: BooleanConstructor;
                readonly src: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly fit: {
                    readonly type: import('vue').PropType<"" | "fill" | "cover" | "contain" | "none" | "scale-down">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly loading: {
                    readonly type: import('vue').PropType<"lazy" | "eager">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly lazy: BooleanConstructor;
                readonly scrollContainer: {
                    readonly type: import('vue').PropType<string | HTMLElement | undefined>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly previewSrcList: {
                    readonly type: import('vue').PropType<string[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => [];
                };
                readonly previewTeleported: BooleanConstructor;
                readonly zIndex: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly initialIndex: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 0;
                };
                readonly infinite: {
                    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 zoomRate: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 1.2;
                };
                readonly minScale: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 0.2;
                };
                readonly maxScale: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 7;
                };
                readonly showProgress: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: false;
                };
                readonly crossorigin: {
                    readonly type: import('vue').PropType<"" | "anonymous" | "use-credentials">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>> & {
                onShow?: (() => any) | undefined;
                onLoad?: ((evt: Event) => any) | undefined;
                onError?: ((evt: Event) => any) | undefined;
                onClose?: (() => any) | undefined;
                onSwitch?: ((val: number) => any) | undefined;
            }, {
                showPreview: () => void;
            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                switch: (val: number) => void;
                show: () => void;
                close: () => void;
                error: (evt: Event) => void;
                load: (evt: Event) => void;
            }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                readonly infinite: boolean;
                readonly src: string;
                readonly fit: "" | "fill" | "cover" | "contain" | "none" | "scale-down";
                readonly initialIndex: number;
                readonly lazy: boolean;
                readonly closeOnPressEscape: boolean;
                readonly zoomRate: number;
                readonly minScale: number;
                readonly maxScale: number;
                readonly showProgress: boolean;
                readonly hideOnClickModal: boolean;
                readonly previewSrcList: string[];
                readonly previewTeleported: boolean;
            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import('vue').ExtractPropTypes<{
                readonly hideOnClickModal: BooleanConstructor;
                readonly src: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly fit: {
                    readonly type: import('vue').PropType<"" | "fill" | "cover" | "contain" | "none" | "scale-down">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly loading: {
                    readonly type: import('vue').PropType<"lazy" | "eager">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly lazy: BooleanConstructor;
                readonly scrollContainer: {
                    readonly type: import('vue').PropType<string | HTMLElement | undefined>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly previewSrcList: {
                    readonly type: import('vue').PropType<string[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => [];
                };
                readonly previewTeleported: BooleanConstructor;
                readonly zIndex: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly initialIndex: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 0;
                };
                readonly infinite: {
                    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 zoomRate: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 1.2;
                };
                readonly minScale: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 0.2;
                };
                readonly maxScale: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 7;
                };
                readonly showProgress: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: false;
                };
                readonly crossorigin: {
                    readonly type: import('vue').PropType<"" | "anonymous" | "use-credentials">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>> & {
                onShow?: (() => any) | undefined;
                onLoad?: ((evt: Event) => any) | undefined;
                onError?: ((evt: Event) => any) | undefined;
                onClose?: (() => any) | undefined;
                onSwitch?: ((val: number) => any) | undefined;
            }, {
                showPreview: () => void;
            }, {}, {}, {}, {
                readonly infinite: boolean;
                readonly src: string;
                readonly fit: "" | "fill" | "cover" | "contain" | "none" | "scale-down";
                readonly initialIndex: number;
                readonly lazy: boolean;
                readonly closeOnPressEscape: boolean;
                readonly zoomRate: number;
                readonly minScale: number;
                readonly maxScale: number;
                readonly showProgress: boolean;
                readonly hideOnClickModal: boolean;
                readonly previewSrcList: string[];
                readonly previewTeleported: boolean;
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
            readonly hideOnClickModal: BooleanConstructor;
            readonly src: {
                readonly type: import('vue').PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            readonly fit: {
                readonly type: import('vue').PropType<"" | "fill" | "cover" | "contain" | "none" | "scale-down">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            readonly loading: {
                readonly type: import('vue').PropType<"lazy" | "eager">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly lazy: BooleanConstructor;
            readonly scrollContainer: {
                readonly type: import('vue').PropType<string | HTMLElement | undefined>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly previewSrcList: {
                readonly type: import('vue').PropType<string[]>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: () => [];
            };
            readonly previewTeleported: BooleanConstructor;
            readonly zIndex: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly initialIndex: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 0;
            };
            readonly infinite: {
                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 zoomRate: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 1.2;
            };
            readonly minScale: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 0.2;
            };
            readonly maxScale: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 7;
            };
            readonly showProgress: {
                readonly type: import('vue').PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: false;
            };
            readonly crossorigin: {
                readonly type: import('vue').PropType<"" | "anonymous" | "use-credentials">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
        }>> & {
            onShow?: (() => any) | undefined;
            onLoad?: ((evt: Event) => any) | undefined;
            onError?: ((evt: Event) => any) | undefined;
            onClose?: (() => any) | undefined;
            onSwitch?: ((val: number) => any) | undefined;
        }, {
            showPreview: () => void;
        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
            switch: (val: number) => void;
            show: () => void;
            close: () => void;
            error: (evt: Event) => void;
            load: (evt: Event) => void;
        }, string, {
            readonly infinite: boolean;
            readonly src: string;
            readonly fit: "" | "fill" | "cover" | "contain" | "none" | "scale-down";
            readonly initialIndex: number;
            readonly lazy: boolean;
            readonly closeOnPressEscape: boolean;
            readonly zoomRate: number;
            readonly minScale: number;
            readonly maxScale: number;
            readonly showProgress: boolean;
            readonly hideOnClickModal: boolean;
            readonly previewSrcList: string[];
            readonly previewTeleported: boolean;
        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
            $slots: {
                error?(_: {}): any;
                placeholder?(_: {}): any;
                viewer?(_: {}): any;
                progress?(_: {
                    activeIndex: number;
                    total: number;
                }): any;
                toolbar?(_: {
                    actions: (action: import('element-plus').ImageViewerAction, options?: {}) => void;
                    prev: () => void;
                    next: () => void;
                    reset: () => void;
                    activeIndex: number;
                    setActiveItem: (index: number) => void;
                }): any;
            };
        }) & import('vue').Plugin;
        ElProgress: {
            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                readonly type: {
                    readonly type: import('vue').PropType<"circle" | "line" | "dashboard">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "line";
                };
                readonly percentage: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 0;
                };
                readonly status: {
                    readonly type: import('vue').PropType<"" | "success" | "warning" | "exception">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly indeterminate: BooleanConstructor;
                readonly duration: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 3;
                };
                readonly strokeWidth: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 6;
                };
                readonly strokeLinecap: {
                    readonly type: import('vue').PropType<NonNullable<"square" | "inherit" | "round" | "butt" | undefined>>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "round";
                };
                readonly textInside: BooleanConstructor;
                readonly width: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 126;
                };
                readonly showText: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                readonly color: {
                    readonly type: import('vue').PropType<string | import('element-plus').ProgressFn | import('element-plus').ProgressColor[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly striped: BooleanConstructor;
                readonly stripedFlow: BooleanConstructor;
                readonly format: {
                    readonly type: import('vue').PropType<import('element-plus').ProgressFn>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: (percentage: number) => string;
                };
            }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                readonly width: number;
                readonly color: string | import('element-plus').ProgressFn | import('element-plus').ProgressColor[];
                readonly strokeLinecap: NonNullable<"square" | "inherit" | "round" | "butt" | undefined>;
                readonly strokeWidth: number;
                readonly type: "circle" | "line" | "dashboard";
                readonly format: import('element-plus').ProgressFn;
                readonly duration: number;
                readonly indeterminate: boolean;
                readonly percentage: number;
                readonly status: "" | "success" | "warning" | "exception";
                readonly showText: boolean;
                readonly textInside: boolean;
                readonly striped: boolean;
                readonly stripedFlow: boolean;
            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import('vue').ExtractPropTypes<{
                readonly type: {
                    readonly type: import('vue').PropType<"circle" | "line" | "dashboard">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "line";
                };
                readonly percentage: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 0;
                };
                readonly status: {
                    readonly type: import('vue').PropType<"" | "success" | "warning" | "exception">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly indeterminate: BooleanConstructor;
                readonly duration: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 3;
                };
                readonly strokeWidth: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 6;
                };
                readonly strokeLinecap: {
                    readonly type: import('vue').PropType<NonNullable<"square" | "inherit" | "round" | "butt" | undefined>>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "round";
                };
                readonly textInside: BooleanConstructor;
                readonly width: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 126;
                };
                readonly showText: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                readonly color: {
                    readonly type: import('vue').PropType<string | import('element-plus').ProgressFn | import('element-plus').ProgressColor[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly striped: BooleanConstructor;
                readonly stripedFlow: BooleanConstructor;
                readonly format: {
                    readonly type: import('vue').PropType<import('element-plus').ProgressFn>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: (percentage: number) => string;
                };
            }>>, {}, {}, {}, {}, {
                readonly width: number;
                readonly color: string | import('element-plus').ProgressFn | import('element-plus').ProgressColor[];
                readonly strokeLinecap: NonNullable<"square" | "inherit" | "round" | "butt" | undefined>;
                readonly strokeWidth: number;
                readonly type: "circle" | "line" | "dashboard";
                readonly format: import('element-plus').ProgressFn;
                readonly duration: number;
                readonly indeterminate: boolean;
                readonly percentage: number;
                readonly status: "" | "success" | "warning" | "exception";
                readonly showText: boolean;
                readonly textInside: boolean;
                readonly striped: boolean;
                readonly stripedFlow: boolean;
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
            readonly type: {
                readonly type: import('vue').PropType<"circle" | "line" | "dashboard">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "line";
            };
            readonly percentage: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 0;
            };
            readonly status: {
                readonly type: import('vue').PropType<"" | "success" | "warning" | "exception">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            readonly indeterminate: BooleanConstructor;
            readonly duration: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 3;
            };
            readonly strokeWidth: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 6;
            };
            readonly strokeLinecap: {
                readonly type: import('vue').PropType<NonNullable<"square" | "inherit" | "round" | "butt" | undefined>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "round";
            };
            readonly textInside: BooleanConstructor;
            readonly width: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 126;
            };
            readonly showText: {
                readonly type: import('vue').PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            readonly color: {
                readonly type: import('vue').PropType<string | import('element-plus').ProgressFn | import('element-plus').ProgressColor[]>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            readonly striped: BooleanConstructor;
            readonly stripedFlow: BooleanConstructor;
            readonly format: {
                readonly type: import('vue').PropType<import('element-plus').ProgressFn>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: (percentage: number) => string;
            };
        }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
            readonly width: number;
            readonly color: string | import('element-plus').ProgressFn | import('element-plus').ProgressColor[];
            readonly strokeLinecap: NonNullable<"square" | "inherit" | "round" | "butt" | undefined>;
            readonly strokeWidth: number;
            readonly type: "circle" | "line" | "dashboard";
            readonly format: import('element-plus').ProgressFn;
            readonly duration: number;
            readonly indeterminate: boolean;
            readonly percentage: number;
            readonly status: "" | "success" | "warning" | "exception";
            readonly showText: boolean;
            readonly textInside: boolean;
            readonly striped: boolean;
            readonly stripedFlow: boolean;
        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
            $slots: {
                default?(_: {
                    percentage: number;
                }): any;
                default?(_: {
                    percentage: number;
                }): 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;
    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
export default _default;