@minto-ai/mt-ui/dist/upload/src/upload.vue.d.ts

UI组件库

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;
            };
            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;
            };
            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" | "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 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;
    success: (args_0: {
        response: IUploadFileSuccessResponse;
        uploadFile: UploadFile;
        uploadFiles: UploadFile[];
    }) => any;
    "update:modelValue": (args_0: UploadFile[]) => any;
    change: (args_0: {
        uploadFile: UploadFile;
        uploadFiles: 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" | "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 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;
    onSuccess?: ((args_0: {
        response: IUploadFileSuccessResponse;
        uploadFile: UploadFile;
        uploadFiles: UploadFile[];
    }) => any) | undefined;
    "onUpdate:modelValue"?: ((args_0: UploadFile[]) => any) | undefined;
    onChange?: ((args_0: {
        uploadFile: UploadFile;
        uploadFiles: UploadFile[];
    }) => any) | undefined;
}>, {
    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;
        };
        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;
        };
        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;
    };
};