yuang-framework-ui-pc 1.1.45 → 1.1.46

package/lib/ele-upload-list/index.d.ts

@@ -0,0 +1,2450 @@
+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;
+}, {}, {}, {}, 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;
+    }, {}, {}, {}, 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;