@mingto/mt-ui 1.1.32

package/dist/upload/src/upload.vue.d.ts

@@ -0,0 +1,825 @@
+import { IUploadFileSuccessResponse } from '@minto-ai/obs-server';
+import { UploadFile, UploadRawFile, ListTypeEnum } from './upload';
+import { fileSizeLimitConfigMap } from './upload-config';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        trigger?: any;
+        tip?: any;
+    }> & {
+        trigger?: any;
+        tip?: any;
+    };
+    refs: {
+        uploadImageOnlyTriggerRef: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                disabled: boolean;
+                multiple: boolean;
+                showTrigger: boolean;
+                autoCropper: boolean;
+                fileList: UploadFile[];
+                onExceed: (files: File[]) => void;
+            }> & Omit<{
+                readonly disabled: boolean;
+                readonly multiple: boolean;
+                readonly showTrigger: boolean;
+                readonly autoCropper: boolean;
+                readonly fileList: UploadFile[];
+                readonly onExceed: (files: File[]) => void;
+                readonly limit?: number | undefined;
+                readonly suffixes?: string[] | undefined;
+                readonly copperOptions?: import('./upload').CopperOptions | undefined;
+                readonly onRemove?: ((...args: any[]) => any) | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "disabled" | "multiple" | "showTrigger" | "autoCropper" | "fileList" | "onExceed">;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                copperRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
+                    open(source: File | string): Promise<{
+                        file: File;
+                    }>;
+                    close(): void;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+                    cropperRef: unknown;
+                }, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<{}> & Readonly<{}>, {
+                    open(source: File | string): Promise<{
+                        file: File;
+                    }>;
+                    close(): void;
+                }, {}, {}, {}, {}> | null;
+                inputRef: HTMLInputElement;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: "remove", ...args: any[]) => void;
+            $el: HTMLDivElement;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                fileList: {
+                    type: import('vue').PropType<UploadFile[]>;
+                    default: () => never[];
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                };
+                limit: {
+                    type: NumberConstructor;
+                };
+                multiple: {
+                    type: BooleanConstructor;
+                };
+                suffixes: {
+                    type: import('vue').PropType<string[]>;
+                };
+                onExceed: {
+                    type: import('vue').PropType<(files: File[]) => void>;
+                    default: typeof import('../../utils').NOOP;
+                };
+                showTrigger: {
+                    type: BooleanConstructor;
+                };
+                autoCropper: {
+                    type: BooleanConstructor;
+                };
+                copperOptions: {
+                    type: import('vue').PropType<import('./upload').CopperOptions>;
+                };
+            }>> & Readonly<{
+                onRemove?: ((...args: any[]) => any) | undefined;
+            }>, {
+                choose(): void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                remove: (...args: any[]) => void;
+            }, string, {
+                disabled: boolean;
+                multiple: boolean;
+                showTrigger: boolean;
+                autoCropper: boolean;
+                fileList: UploadFile[];
+                onExceed: (files: File[]) => void;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import('vue').nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{
+            disabled: boolean;
+            multiple: boolean;
+            showTrigger: boolean;
+            autoCropper: boolean;
+            fileList: UploadFile[];
+            onExceed: (files: File[]) => void;
+        }> & Omit<Readonly<import('vue').ExtractPropTypes<{
+            fileList: {
+                type: import('vue').PropType<UploadFile[]>;
+                default: () => never[];
+            };
+            disabled: {
+                type: BooleanConstructor;
+            };
+            limit: {
+                type: NumberConstructor;
+            };
+            multiple: {
+                type: BooleanConstructor;
+            };
+            suffixes: {
+                type: import('vue').PropType<string[]>;
+            };
+            onExceed: {
+                type: import('vue').PropType<(files: File[]) => void>;
+                default: typeof import('../../utils').NOOP;
+            };
+            showTrigger: {
+                type: BooleanConstructor;
+            };
+            autoCropper: {
+                type: BooleanConstructor;
+            };
+            copperOptions: {
+                type: import('vue').PropType<import('./upload').CopperOptions>;
+            };
+        }>> & Readonly<{
+            onRemove?: ((...args: any[]) => any) | undefined;
+        }>, "choose" | ("disabled" | "multiple" | "showTrigger" | "autoCropper" | "fileList" | "onExceed")> & import('vue').ShallowUnwrapRef<{
+            choose(): void;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: Readonly<Record<string, any>> & Record<string, any>;
+        }) | null;
+        uploadRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+            fileList: {
+                type: import('vue').PropType<UploadFile[]>;
+                default: () => never[];
+            };
+            limit: {
+                type: NumberConstructor;
+            };
+            multiple: {
+                type: BooleanConstructor;
+            };
+            size: {
+                type: NumberConstructor;
+            };
+            suffixes: {
+                type: import('vue').PropType<import('@minto-ai/tools').FileSuffix[]>;
+            };
+            disabled: {
+                type: BooleanConstructor;
+            };
+            onExceed: {
+                type: import('vue').PropType<(files: File[]) => void>;
+                default: typeof import('../../utils').NOOP;
+            };
+            onStart: {
+                type: import('vue').PropType<(rawFile: UploadRawFile) => void>;
+                default: () => void;
+            };
+            onReload: {
+                type: import('vue').PropType<(rawFile: UploadRawFile) => void>;
+                default: typeof import('../../utils').NOOP;
+            };
+            onProgress: {
+                type: import('vue').PropType<(evtnt: import('./upload').UploadProgressEvent, rawFile: UploadRawFile) => void>;
+                default: typeof import('../../utils').NOOP;
+            };
+            onError: {
+                type: import('vue').PropType<(error: Error, rawFile: UploadRawFile) => void>;
+                default: typeof import('../../utils').NOOP;
+            };
+            onSuccess: {
+                type: import('vue').PropType<(response: IUploadFileSuccessResponse, rawFile: UploadRawFile) => void>;
+                default: typeof import('../../utils').NOOP;
+            };
+            onRemove: {
+                type: import('vue').PropType<(rawFile: UploadRawFile) => void>;
+                default: typeof import('../../utils').NOOP;
+            };
+            beforeUpload: {
+                type: import('vue').PropType<(rawFile: UploadRawFile) => Promise<boolean> | boolean>;
+                default: typeof import('../../utils').NOOP;
+            };
+        }>> & Readonly<{}>, {
+            abort: (uploadFile?: UploadFile) => void;
+            choose: () => void;
+            reload: (uid: number, file: File) => void;
+            upload: (files: Array<File>) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+            onError: (error: Error, rawFile: UploadRawFile) => void;
+            onProgress: (evtnt: import('./upload').UploadProgressEvent, rawFile: UploadRawFile) => void;
+            disabled: boolean;
+            multiple: boolean;
+            beforeUpload: (rawFile: UploadRawFile) => Promise<boolean> | boolean;
+            fileList: UploadFile[];
+            onRemove: (rawFile: UploadRawFile) => void;
+            onExceed: (files: File[]) => void;
+            onStart: (rawFile: UploadRawFile) => void;
+            onReload: (rawFile: UploadRawFile) => void;
+            onSuccess: (response: IUploadFileSuccessResponse, rawFile: UploadRawFile) => void;
+        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+            inputRef: HTMLInputElement;
+        }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('vue').ExtractPropTypes<{
+            fileList: {
+                type: import('vue').PropType<UploadFile[]>;
+                default: () => never[];
+            };
+            limit: {
+                type: NumberConstructor;
+            };
+            multiple: {
+                type: BooleanConstructor;
+            };
+            size: {
+                type: NumberConstructor;
+            };
+            suffixes: {
+                type: import('vue').PropType<import('@minto-ai/tools').FileSuffix[]>;
+            };
+            disabled: {
+                type: BooleanConstructor;
+            };
+            onExceed: {
+                type: import('vue').PropType<(files: File[]) => void>;
+                default: typeof import('../../utils').NOOP;
+            };
+            onStart: {
+                type: import('vue').PropType<(rawFile: UploadRawFile) => void>;
+                default: () => void;
+            };
+            onReload: {
+                type: import('vue').PropType<(rawFile: UploadRawFile) => void>;
+                default: typeof import('../../utils').NOOP;
+            };
+            onProgress: {
+                type: import('vue').PropType<(evtnt: import('./upload').UploadProgressEvent, rawFile: UploadRawFile) => void>;
+                default: typeof import('../../utils').NOOP;
+            };
+            onError: {
+                type: import('vue').PropType<(error: Error, rawFile: UploadRawFile) => void>;
+                default: typeof import('../../utils').NOOP;
+            };
+            onSuccess: {
+                type: import('vue').PropType<(response: IUploadFileSuccessResponse, rawFile: UploadRawFile) => void>;
+                default: typeof import('../../utils').NOOP;
+            };
+            onRemove: {
+                type: import('vue').PropType<(rawFile: UploadRawFile) => void>;
+                default: typeof import('../../utils').NOOP;
+            };
+            beforeUpload: {
+                type: import('vue').PropType<(rawFile: UploadRawFile) => Promise<boolean> | boolean>;
+                default: typeof import('../../utils').NOOP;
+            };
+        }>> & Readonly<{}>, {
+            abort: (uploadFile?: UploadFile) => void;
+            choose: () => void;
+            reload: (uid: number, file: File) => void;
+            upload: (files: Array<File>) => void;
+        }, {}, {}, {}, {
+            onError: (error: Error, rawFile: UploadRawFile) => void;
+            onProgress: (evtnt: import('./upload').UploadProgressEvent, rawFile: UploadRawFile) => void;
+            disabled: boolean;
+            multiple: boolean;
+            beforeUpload: (rawFile: UploadRawFile) => Promise<boolean> | boolean;
+            fileList: UploadFile[];
+            onRemove: (rawFile: UploadRawFile) => void;
+            onExceed: (files: File[]) => void;
+            onStart: (rawFile: UploadRawFile) => void;
+            onReload: (rawFile: UploadRawFile) => void;
+            onSuccess: (response: IUploadFileSuccessResponse, rawFile: UploadRawFile) => void;
+        }> | null;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    readonly modelValue: {
+        readonly type: import('vue').PropType<UploadFile[]>;
+        readonly default: () => never[];
+    };
+    readonly limit: {
+        readonly type: NumberConstructor;
+        readonly default: 9;
+    };
+    readonly multiple: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly suffixes: {
+        readonly type: import('vue').PropType<import('@minto-ai/tools').FileSuffix[]>;
+        readonly default: ("html" | "ppt" | "docx" | "doc" | "pdf" | "pptx" | "xlsx" | "xls" | "jpg" | "png" | "jpeg" | "webp" | "gif" | "mp4" | "avi" | "flv" | "mkv" | "mp3" | "wav" | "txt" | "json" | "zip" | "rar")[];
+    };
+    readonly disabled: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly listType: {
+        readonly type: import('vue').PropType<ListTypeEnum>;
+        readonly default: ListTypeEnum.FILE_LIST;
+        readonly values: ListTypeEnum[];
+    };
+    readonly showTrigger: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly showList: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly isFullScreeDrag: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly sizeType: {
+        readonly type: import('vue').PropType<keyof typeof fileSizeLimitConfigMap>;
+        readonly default: "normal";
+        readonly values: MapIterator<string>;
+    };
+    readonly size: {
+        readonly type: NumberConstructor;
+        readonly default: 0;
+    };
+    readonly autoCropper: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly copperOptions: {
+        readonly type: import('vue').PropType<import('./upload').CopperOptions>;
+        readonly default: () => {};
+    };
+    readonly beforeUpload: {
+        readonly type: import('vue').PropType<(rawFile: UploadRawFile) => Promise<boolean | void>>;
+        readonly default: () => Promise<void>;
+    };
+}>, {
+    abort(uploadFile: UploadFile): void;
+    remove(uploadFile: UploadFile): void;
+    choose(): void;
+    format(data: string[] | {
+        url: string;
+    }[] | UploadFile[]): UploadFile[];
+    validate(isRequired?: boolean): boolean;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    error: (args_0: {
+        error: Error;
+        uploadFile: UploadFile;
+        uploadFiles: UploadFile[];
+    }) => any;
+    change: (args_0: {
+        uploadFile: UploadFile;
+        uploadFiles: UploadFile[];
+    }) => any;
+    success: (args_0: {
+        response: IUploadFileSuccessResponse;
+        uploadFile: UploadFile;
+        uploadFiles: UploadFile[];
+    }) => any;
+    "update:modelValue": (args_0: UploadFile[]) => any;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    readonly modelValue: {
+        readonly type: import('vue').PropType<UploadFile[]>;
+        readonly default: () => never[];
+    };
+    readonly limit: {
+        readonly type: NumberConstructor;
+        readonly default: 9;
+    };
+    readonly multiple: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly suffixes: {
+        readonly type: import('vue').PropType<import('@minto-ai/tools').FileSuffix[]>;
+        readonly default: ("html" | "ppt" | "docx" | "doc" | "pdf" | "pptx" | "xlsx" | "xls" | "jpg" | "png" | "jpeg" | "webp" | "gif" | "mp4" | "avi" | "flv" | "mkv" | "mp3" | "wav" | "txt" | "json" | "zip" | "rar")[];
+    };
+    readonly disabled: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly listType: {
+        readonly type: import('vue').PropType<ListTypeEnum>;
+        readonly default: ListTypeEnum.FILE_LIST;
+        readonly values: ListTypeEnum[];
+    };
+    readonly showTrigger: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly showList: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly isFullScreeDrag: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly sizeType: {
+        readonly type: import('vue').PropType<keyof typeof fileSizeLimitConfigMap>;
+        readonly default: "normal";
+        readonly values: MapIterator<string>;
+    };
+    readonly size: {
+        readonly type: NumberConstructor;
+        readonly default: 0;
+    };
+    readonly autoCropper: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly copperOptions: {
+        readonly type: import('vue').PropType<import('./upload').CopperOptions>;
+        readonly default: () => {};
+    };
+    readonly beforeUpload: {
+        readonly type: import('vue').PropType<(rawFile: UploadRawFile) => Promise<boolean | void>>;
+        readonly default: () => Promise<void>;
+    };
+}>> & Readonly<{
+    onError?: ((args_0: {
+        error: Error;
+        uploadFile: UploadFile;
+        uploadFiles: UploadFile[];
+    }) => any) | undefined;
+    onChange?: ((args_0: {
+        uploadFile: UploadFile;
+        uploadFiles: UploadFile[];
+    }) => any) | undefined;
+    onSuccess?: ((args_0: {
+        response: IUploadFileSuccessResponse;
+        uploadFile: UploadFile;
+        uploadFiles: UploadFile[];
+    }) => any) | undefined;
+    "onUpdate:modelValue"?: ((args_0: UploadFile[]) => any) | undefined;
+}>, {
+    readonly size: number;
+    readonly disabled: boolean;
+    readonly modelValue: UploadFile[];
+    readonly limit: number;
+    readonly multiple: boolean;
+    readonly suffixes: import('@minto-ai/tools').FileSuffix[];
+    readonly listType: ListTypeEnum;
+    readonly showTrigger: boolean;
+    readonly showList: boolean;
+    readonly isFullScreeDrag: boolean;
+    readonly sizeType: keyof Map<string, Record<import('@minto-ai/tools').FileSuffix, number>>;
+    readonly autoCropper: boolean;
+    readonly copperOptions: import('./upload').CopperOptions;
+    readonly beforeUpload: (rawFile: UploadRawFile) => Promise<boolean | void>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    uploadImageOnlyTriggerRef: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            disabled: boolean;
+            multiple: boolean;
+            showTrigger: boolean;
+            autoCropper: boolean;
+            fileList: UploadFile[];
+            onExceed: (files: File[]) => void;
+        }> & Omit<{
+            readonly disabled: boolean;
+            readonly multiple: boolean;
+            readonly showTrigger: boolean;
+            readonly autoCropper: boolean;
+            readonly fileList: UploadFile[];
+            readonly onExceed: (files: File[]) => void;
+            readonly limit?: number | undefined;
+            readonly suffixes?: string[] | undefined;
+            readonly copperOptions?: import('./upload').CopperOptions | undefined;
+            readonly onRemove?: ((...args: any[]) => any) | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "disabled" | "multiple" | "showTrigger" | "autoCropper" | "fileList" | "onExceed">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            copperRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
+                open(source: File | string): Promise<{
+                    file: File;
+                }>;
+                close(): void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+                cropperRef: unknown;
+            }, any, import('vue').ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<{}> & Readonly<{}>, {
+                open(source: File | string): Promise<{
+                    file: File;
+                }>;
+                close(): void;
+            }, {}, {}, {}, {}> | null;
+            inputRef: HTMLInputElement;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: "remove", ...args: any[]) => void;
+        $el: HTMLDivElement;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+            fileList: {
+                type: import('vue').PropType<UploadFile[]>;
+                default: () => never[];
+            };
+            disabled: {
+                type: BooleanConstructor;
+            };
+            limit: {
+                type: NumberConstructor;
+            };
+            multiple: {
+                type: BooleanConstructor;
+            };
+            suffixes: {
+                type: import('vue').PropType<string[]>;
+            };
+            onExceed: {
+                type: import('vue').PropType<(files: File[]) => void>;
+                default: typeof import('../../utils').NOOP;
+            };
+            showTrigger: {
+                type: BooleanConstructor;
+            };
+            autoCropper: {
+                type: BooleanConstructor;
+            };
+            copperOptions: {
+                type: import('vue').PropType<import('./upload').CopperOptions>;
+            };
+        }>> & Readonly<{
+            onRemove?: ((...args: any[]) => any) | undefined;
+        }>, {
+            choose(): void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            remove: (...args: any[]) => void;
+        }, string, {
+            disabled: boolean;
+            multiple: boolean;
+            showTrigger: boolean;
+            autoCropper: boolean;
+            fileList: UploadFile[];
+            onExceed: (files: File[]) => void;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        disabled: boolean;
+        multiple: boolean;
+        showTrigger: boolean;
+        autoCropper: boolean;
+        fileList: UploadFile[];
+        onExceed: (files: File[]) => void;
+    }> & Omit<Readonly<import('vue').ExtractPropTypes<{
+        fileList: {
+            type: import('vue').PropType<UploadFile[]>;
+            default: () => never[];
+        };
+        disabled: {
+            type: BooleanConstructor;
+        };
+        limit: {
+            type: NumberConstructor;
+        };
+        multiple: {
+            type: BooleanConstructor;
+        };
+        suffixes: {
+            type: import('vue').PropType<string[]>;
+        };
+        onExceed: {
+            type: import('vue').PropType<(files: File[]) => void>;
+            default: typeof import('../../utils').NOOP;
+        };
+        showTrigger: {
+            type: BooleanConstructor;
+        };
+        autoCropper: {
+            type: BooleanConstructor;
+        };
+        copperOptions: {
+            type: import('vue').PropType<import('./upload').CopperOptions>;
+        };
+    }>> & Readonly<{
+        onRemove?: ((...args: any[]) => any) | undefined;
+    }>, "choose" | ("disabled" | "multiple" | "showTrigger" | "autoCropper" | "fileList" | "onExceed")> & import('vue').ShallowUnwrapRef<{
+        choose(): void;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: Readonly<Record<string, any>> & Record<string, any>;
+    }) | null;
+    uploadRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        fileList: {
+            type: import('vue').PropType<UploadFile[]>;
+            default: () => never[];
+        };
+        limit: {
+            type: NumberConstructor;
+        };
+        multiple: {
+            type: BooleanConstructor;
+        };
+        size: {
+            type: NumberConstructor;
+        };
+        suffixes: {
+            type: import('vue').PropType<import('@minto-ai/tools').FileSuffix[]>;
+        };
+        disabled: {
+            type: BooleanConstructor;
+        };
+        onExceed: {
+            type: import('vue').PropType<(files: File[]) => void>;
+            default: typeof import('../../utils').NOOP;
+        };
+        onStart: {
+            type: import('vue').PropType<(rawFile: UploadRawFile) => void>;
+            default: () => void;
+        };
+        onReload: {
+            type: import('vue').PropType<(rawFile: UploadRawFile) => void>;
+            default: typeof import('../../utils').NOOP;
+        };
+        onProgress: {
+            type: import('vue').PropType<(evtnt: import('./upload').UploadProgressEvent, rawFile: UploadRawFile) => void>;
+            default: typeof import('../../utils').NOOP;
+        };
+        onError: {
+            type: import('vue').PropType<(error: Error, rawFile: UploadRawFile) => void>;
+            default: typeof import('../../utils').NOOP;
+        };
+        onSuccess: {
+            type: import('vue').PropType<(response: IUploadFileSuccessResponse, rawFile: UploadRawFile) => void>;
+            default: typeof import('../../utils').NOOP;
+        };
+        onRemove: {
+            type: import('vue').PropType<(rawFile: UploadRawFile) => void>;
+            default: typeof import('../../utils').NOOP;
+        };
+        beforeUpload: {
+            type: import('vue').PropType<(rawFile: UploadRawFile) => Promise<boolean> | boolean>;
+            default: typeof import('../../utils').NOOP;
+        };
+    }>> & Readonly<{}>, {
+        abort: (uploadFile?: UploadFile) => void;
+        choose: () => void;
+        reload: (uid: number, file: File) => void;
+        upload: (files: Array<File>) => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        onError: (error: Error, rawFile: UploadRawFile) => void;
+        onProgress: (evtnt: import('./upload').UploadProgressEvent, rawFile: UploadRawFile) => void;
+        disabled: boolean;
+        multiple: boolean;
+        beforeUpload: (rawFile: UploadRawFile) => Promise<boolean> | boolean;
+        fileList: UploadFile[];
+        onRemove: (rawFile: UploadRawFile) => void;
+        onExceed: (files: File[]) => void;
+        onStart: (rawFile: UploadRawFile) => void;
+        onReload: (rawFile: UploadRawFile) => void;
+        onSuccess: (response: IUploadFileSuccessResponse, rawFile: UploadRawFile) => void;
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        inputRef: HTMLInputElement;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        fileList: {
+            type: import('vue').PropType<UploadFile[]>;
+            default: () => never[];
+        };
+        limit: {
+            type: NumberConstructor;
+        };
+        multiple: {
+            type: BooleanConstructor;
+        };
+        size: {
+            type: NumberConstructor;
+        };
+        suffixes: {
+            type: import('vue').PropType<import('@minto-ai/tools').FileSuffix[]>;
+        };
+        disabled: {
+            type: BooleanConstructor;
+        };
+        onExceed: {
+            type: import('vue').PropType<(files: File[]) => void>;
+            default: typeof import('../../utils').NOOP;
+        };
+        onStart: {
+            type: import('vue').PropType<(rawFile: UploadRawFile) => void>;
+            default: () => void;
+        };
+        onReload: {
+            type: import('vue').PropType<(rawFile: UploadRawFile) => void>;
+            default: typeof import('../../utils').NOOP;
+        };
+        onProgress: {
+            type: import('vue').PropType<(evtnt: import('./upload').UploadProgressEvent, rawFile: UploadRawFile) => void>;
+            default: typeof import('../../utils').NOOP;
+        };
+        onError: {
+            type: import('vue').PropType<(error: Error, rawFile: UploadRawFile) => void>;
+            default: typeof import('../../utils').NOOP;
+        };
+        onSuccess: {
+            type: import('vue').PropType<(response: IUploadFileSuccessResponse, rawFile: UploadRawFile) => void>;
+            default: typeof import('../../utils').NOOP;
+        };
+        onRemove: {
+            type: import('vue').PropType<(rawFile: UploadRawFile) => void>;
+            default: typeof import('../../utils').NOOP;
+        };
+        beforeUpload: {
+            type: import('vue').PropType<(rawFile: UploadRawFile) => Promise<boolean> | boolean>;
+            default: typeof import('../../utils').NOOP;
+        };
+    }>> & Readonly<{}>, {
+        abort: (uploadFile?: UploadFile) => void;
+        choose: () => void;
+        reload: (uid: number, file: File) => void;
+        upload: (files: Array<File>) => void;
+    }, {}, {}, {}, {
+        onError: (error: Error, rawFile: UploadRawFile) => void;
+        onProgress: (evtnt: import('./upload').UploadProgressEvent, rawFile: UploadRawFile) => void;
+        disabled: boolean;
+        multiple: boolean;
+        beforeUpload: (rawFile: UploadRawFile) => Promise<boolean> | boolean;
+        fileList: UploadFile[];
+        onRemove: (rawFile: UploadRawFile) => void;
+        onExceed: (files: File[]) => void;
+        onStart: (rawFile: UploadRawFile) => void;
+        onReload: (rawFile: UploadRawFile) => void;
+        onSuccess: (response: IUploadFileSuccessResponse, rawFile: UploadRawFile) => void;
+    }> | null;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};