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

UI组件库

export declare const MtUpload: {
    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
        readonly modelValue: {
            readonly type: import('vue').PropType<import('.').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<import('.').ListTypeEnum>;
            readonly default: import(".").ListTypeEnum.FILE_LIST;
            readonly values: import('.').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 Map<string, Record<import('@minto-ai/tools').FileSuffix, number>>>;
            readonly default: "normal";
            readonly values: MapIterator<string>;
        };
        readonly autoCropper: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly copperOptions: {
            readonly type: import('vue').PropType<import('.').CopperOptions>;
            readonly default: () => {};
        };
        readonly beforeUpload: {
            readonly type: import('vue').PropType<(rawFile: import('.').UploadRawFile) => Promise<boolean | void>>;
            readonly default: () => Promise<void>;
        };
    }>> & Readonly<{
        onError?: ((args_0: {
            error: Error;
            uploadFile: import('.').UploadFile;
            uploadFiles: import('.').UploadFile[];
        }) => any) | undefined;
        onSuccess?: ((args_0: {
            response: import('@minto-ai/obs-server').IUploadFileSuccessResponse;
            uploadFile: import('.').UploadFile;
            uploadFiles: import('.').UploadFile[];
        }) => any) | undefined;
        "onUpdate:modelValue"?: ((args_0: import('.').UploadFile[]) => any) | undefined;
        onChange?: ((args_0: {
            uploadFile: import('.').UploadFile;
            uploadFiles: import('.').UploadFile[];
        }) => any) | undefined;
    }>, {
        abort(uploadFile: import('.').UploadFile): void;
        remove(uploadFile: import('.').UploadFile): void;
        choose(): void;
        format(data: string[] | {
            url: string;
        }[] | import('.').UploadFile[]): import('.').UploadFile[];
        validate(isRequired?: boolean): boolean;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
        error: (args_0: {
            error: Error;
            uploadFile: import('.').UploadFile;
            uploadFiles: import('.').UploadFile[];
        }) => any;
        success: (args_0: {
            response: import('@minto-ai/obs-server').IUploadFileSuccessResponse;
            uploadFile: import('.').UploadFile;
            uploadFiles: import('.').UploadFile[];
        }) => any;
        "update:modelValue": (args_0: import('.').UploadFile[]) => any;
        change: (args_0: {
            uploadFile: import('.').UploadFile;
            uploadFiles: import('.').UploadFile[];
        }) => any;
    }, import('vue').PublicProps, {
        readonly disabled: boolean;
        readonly modelValue: import('.').UploadFile[];
        readonly limit: number;
        readonly multiple: boolean;
        readonly suffixes: import('@minto-ai/tools').FileSuffix[];
        readonly listType: import('.').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('.').CopperOptions;
        readonly beforeUpload: (rawFile: import('.').UploadRawFile) => Promise<boolean | void>;
    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
        uploadImageOnlyTriggerRef: ({
            $: import('vue').ComponentInternalInstance;
            $data: {};
            $props: Partial<{
                disabled: boolean;
                multiple: boolean;
                showTrigger: boolean;
                autoCropper: boolean;
                fileList: import('.').UploadFile[];
                onExceed: (files: File[]) => void;
            }> & Omit<{
                readonly disabled: boolean;
                readonly multiple: boolean;
                readonly showTrigger: boolean;
                readonly autoCropper: boolean;
                readonly fileList: import('.').UploadFile[];
                readonly onExceed: (files: File[]) => void;
                readonly limit?: number | undefined;
                readonly suffixes?: string[] | undefined;
                readonly copperOptions?: import('.').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<import('.').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('.').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: import('.').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: import('.').UploadFile[];
            onExceed: (files: File[]) => void;
        }> & Omit<Readonly<import('vue').ExtractPropTypes<{
            fileList: {
                type: import('vue').PropType<import('.').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('.').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<import('.').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: import('.').UploadRawFile) => void>;
                default: () => void;
            };
            onReload: {
                type: import('vue').PropType<(rawFile: import('.').UploadRawFile) => void>;
                default: typeof import('../utils').NOOP;
            };
            onProgress: {
                type: import('vue').PropType<(evtnt: import('.').UploadProgressEvent, rawFile: import('.').UploadRawFile) => void>;
                default: typeof import('../utils').NOOP;
            };
            onError: {
                type: import('vue').PropType<(error: Error, rawFile: import('.').UploadRawFile) => void>;
                default: typeof import('../utils').NOOP;
            };
            onSuccess: {
                type: import('vue').PropType<(response: import('@minto-ai/obs-server').IUploadFileSuccessResponse, rawFile: import('.').UploadRawFile) => void>;
                default: typeof import('../utils').NOOP;
            };
            onRemove: {
                type: import('vue').PropType<(rawFile: import('.').UploadRawFile) => void>;
                default: typeof import('../utils').NOOP;
            };
            beforeUpload: {
                type: import('vue').PropType<(rawFile: import('.').UploadRawFile) => Promise<boolean> | boolean>;
                default: typeof import('../utils').NOOP;
            };
        }>> & Readonly<{}>, {
            abort: (uploadFile?: import('.').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: import('.').UploadRawFile) => void;
            onProgress: (evtnt: import('.').UploadProgressEvent, rawFile: import('.').UploadRawFile) => void;
            disabled: boolean;
            multiple: boolean;
            beforeUpload: (rawFile: import('.').UploadRawFile) => Promise<boolean> | boolean;
            fileList: import('.').UploadFile[];
            onRemove: (rawFile: import('.').UploadRawFile) => void;
            onExceed: (files: File[]) => void;
            onStart: (rawFile: import('.').UploadRawFile) => void;
            onReload: (rawFile: import('.').UploadRawFile) => void;
            onSuccess: (response: import('@minto-ai/obs-server').IUploadFileSuccessResponse, rawFile: import('.').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<import('.').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: import('.').UploadRawFile) => void>;
                default: () => void;
            };
            onReload: {
                type: import('vue').PropType<(rawFile: import('.').UploadRawFile) => void>;
                default: typeof import('../utils').NOOP;
            };
            onProgress: {
                type: import('vue').PropType<(evtnt: import('.').UploadProgressEvent, rawFile: import('.').UploadRawFile) => void>;
                default: typeof import('../utils').NOOP;
            };
            onError: {
                type: import('vue').PropType<(error: Error, rawFile: import('.').UploadRawFile) => void>;
                default: typeof import('../utils').NOOP;
            };
            onSuccess: {
                type: import('vue').PropType<(response: import('@minto-ai/obs-server').IUploadFileSuccessResponse, rawFile: import('.').UploadRawFile) => void>;
                default: typeof import('../utils').NOOP;
            };
            onRemove: {
                type: import('vue').PropType<(rawFile: import('.').UploadRawFile) => void>;
                default: typeof import('../utils').NOOP;
            };
            beforeUpload: {
                type: import('vue').PropType<(rawFile: import('.').UploadRawFile) => Promise<boolean> | boolean>;
                default: typeof import('../utils').NOOP;
            };
        }>> & Readonly<{}>, {
            abort: (uploadFile?: import('.').UploadFile) => void;
            choose: () => void;
            reload: (uid: number, file: File) => void;
            upload: (files: Array<File>) => void;
        }, {}, {}, {}, {
            onError: (error: Error, rawFile: import('.').UploadRawFile) => void;
            onProgress: (evtnt: import('.').UploadProgressEvent, rawFile: import('.').UploadRawFile) => void;
            disabled: boolean;
            multiple: boolean;
            beforeUpload: (rawFile: import('.').UploadRawFile) => Promise<boolean> | boolean;
            fileList: import('.').UploadFile[];
            onRemove: (rawFile: import('.').UploadRawFile) => void;
            onExceed: (files: File[]) => void;
            onStart: (rawFile: import('.').UploadRawFile) => void;
            onReload: (rawFile: import('.').UploadRawFile) => void;
            onSuccess: (response: import('@minto-ai/obs-server').IUploadFileSuccessResponse, rawFile: import('.').UploadRawFile) => void;
        }> | null;
    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<import('vue').ExtractPropTypes<{
        readonly modelValue: {
            readonly type: import('vue').PropType<import('.').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<import('.').ListTypeEnum>;
            readonly default: import(".").ListTypeEnum.FILE_LIST;
            readonly values: import('.').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 Map<string, Record<import('@minto-ai/tools').FileSuffix, number>>>;
            readonly default: "normal";
            readonly values: MapIterator<string>;
        };
        readonly autoCropper: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly copperOptions: {
            readonly type: import('vue').PropType<import('.').CopperOptions>;
            readonly default: () => {};
        };
        readonly beforeUpload: {
            readonly type: import('vue').PropType<(rawFile: import('.').UploadRawFile) => Promise<boolean | void>>;
            readonly default: () => Promise<void>;
        };
    }>> & Readonly<{
        onError?: ((args_0: {
            error: Error;
            uploadFile: import('.').UploadFile;
            uploadFiles: import('.').UploadFile[];
        }) => any) | undefined;
        onSuccess?: ((args_0: {
            response: import('@minto-ai/obs-server').IUploadFileSuccessResponse;
            uploadFile: import('.').UploadFile;
            uploadFiles: import('.').UploadFile[];
        }) => any) | undefined;
        "onUpdate:modelValue"?: ((args_0: import('.').UploadFile[]) => any) | undefined;
        onChange?: ((args_0: {
            uploadFile: import('.').UploadFile;
            uploadFiles: import('.').UploadFile[];
        }) => any) | undefined;
    }>, {
        abort(uploadFile: import('.').UploadFile): void;
        remove(uploadFile: import('.').UploadFile): void;
        choose(): void;
        format(data: string[] | {
            url: string;
        }[] | import('.').UploadFile[]): import('.').UploadFile[];
        validate(isRequired?: boolean): boolean;
    }, {}, {}, {}, {
        readonly disabled: boolean;
        readonly modelValue: import('.').UploadFile[];
        readonly limit: number;
        readonly multiple: boolean;
        readonly suffixes: import('@minto-ai/tools').FileSuffix[];
        readonly listType: import('.').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('.').CopperOptions;
        readonly beforeUpload: (rawFile: import('.').UploadRawFile) => Promise<boolean | void>;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
    readonly modelValue: {
        readonly type: import('vue').PropType<import('.').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<import('.').ListTypeEnum>;
        readonly default: import(".").ListTypeEnum.FILE_LIST;
        readonly values: import('.').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 Map<string, Record<import('@minto-ai/tools').FileSuffix, number>>>;
        readonly default: "normal";
        readonly values: MapIterator<string>;
    };
    readonly autoCropper: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly copperOptions: {
        readonly type: import('vue').PropType<import('.').CopperOptions>;
        readonly default: () => {};
    };
    readonly beforeUpload: {
        readonly type: import('vue').PropType<(rawFile: import('.').UploadRawFile) => Promise<boolean | void>>;
        readonly default: () => Promise<void>;
    };
}>> & Readonly<{
    onError?: ((args_0: {
        error: Error;
        uploadFile: import('.').UploadFile;
        uploadFiles: import('.').UploadFile[];
    }) => any) | undefined;
    onSuccess?: ((args_0: {
        response: import('@minto-ai/obs-server').IUploadFileSuccessResponse;
        uploadFile: import('.').UploadFile;
        uploadFiles: import('.').UploadFile[];
    }) => any) | undefined;
    "onUpdate:modelValue"?: ((args_0: import('.').UploadFile[]) => any) | undefined;
    onChange?: ((args_0: {
        uploadFile: import('.').UploadFile;
        uploadFiles: import('.').UploadFile[];
    }) => any) | undefined;
}>, {
    abort(uploadFile: import('.').UploadFile): void;
    remove(uploadFile: import('.').UploadFile): void;
    choose(): void;
    format(data: string[] | {
        url: string;
    }[] | import('.').UploadFile[]): import('.').UploadFile[];
    validate(isRequired?: boolean): boolean;
}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
    error: (args_0: {
        error: Error;
        uploadFile: import('.').UploadFile;
        uploadFiles: import('.').UploadFile[];
    }) => any;
    success: (args_0: {
        response: import('@minto-ai/obs-server').IUploadFileSuccessResponse;
        uploadFile: import('.').UploadFile;
        uploadFiles: import('.').UploadFile[];
    }) => any;
    "update:modelValue": (args_0: import('.').UploadFile[]) => any;
    change: (args_0: {
        uploadFile: import('.').UploadFile;
        uploadFiles: import('.').UploadFile[];
    }) => any;
}, string, {
    readonly disabled: boolean;
    readonly modelValue: import('.').UploadFile[];
    readonly limit: number;
    readonly multiple: boolean;
    readonly suffixes: import('@minto-ai/tools').FileSuffix[];
    readonly listType: import('.').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('.').CopperOptions;
    readonly beforeUpload: (rawFile: import('.').UploadRawFile) => Promise<boolean | void>;
}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
    $slots: Readonly<{
        trigger?: any;
        tip?: any;
    }> & {
        trigger?: any;
        tip?: any;
    };
}) & import('vue').Plugin;
export declare const MtUploadFileListLayout: {
    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
        fileList: {
            type: import('vue').PropType<import('.').UploadFile[]>;
            default: () => never[];
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>> & Readonly<{
        onRemove?: ((...args: any[]) => any) | undefined;
    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
        remove: (...args: any[]) => void;
    }, import('vue').PublicProps, {
        disabled: boolean;
        fileList: import('.').UploadFile[];
    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<import('vue').ExtractPropTypes<{
        fileList: {
            type: import('vue').PropType<import('.').UploadFile[]>;
            default: () => never[];
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>> & Readonly<{
        onRemove?: ((...args: any[]) => any) | undefined;
    }>, {}, {}, {}, {}, {
        disabled: boolean;
        fileList: import('.').UploadFile[];
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
    fileList: {
        type: import('vue').PropType<import('.').UploadFile[]>;
        default: () => never[];
    };
    disabled: {
        type: BooleanConstructor;
        default: boolean;
    };
}>> & Readonly<{
    onRemove?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
    remove: (...args: any[]) => void;
}, string, {
    disabled: boolean;
    fileList: import('.').UploadFile[];
}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & import('vue').Plugin;
export declare const MtUploadImageGridLayout: {
    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
        fileList: {
            type: import('vue').PropType<import('.').UploadFile[]>;
            default: () => never[];
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        copperOptions: {
            type: import('vue').PropType<import('.').CopperOptions>;
            default: () => {};
        };
    }>> & Readonly<{
        onRemove?: ((...args: any[]) => any) | undefined;
    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
        remove: (...args: any[]) => void;
    }, import('vue').PublicProps, {
        disabled: boolean;
        copperOptions: import('.').CopperOptions;
        fileList: import('.').UploadFile[];
    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
        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;
    }, any, import('vue').ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<import('vue').ExtractPropTypes<{
        fileList: {
            type: import('vue').PropType<import('.').UploadFile[]>;
            default: () => never[];
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        copperOptions: {
            type: import('vue').PropType<import('.').CopperOptions>;
            default: () => {};
        };
    }>> & Readonly<{
        onRemove?: ((...args: any[]) => any) | undefined;
    }>, {}, {}, {}, {}, {
        disabled: boolean;
        copperOptions: import('.').CopperOptions;
        fileList: import('.').UploadFile[];
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
    fileList: {
        type: import('vue').PropType<import('.').UploadFile[]>;
        default: () => never[];
    };
    disabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    copperOptions: {
        type: import('vue').PropType<import('.').CopperOptions>;
        default: () => {};
    };
}>> & Readonly<{
    onRemove?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
    remove: (...args: any[]) => void;
}, string, {
    disabled: boolean;
    copperOptions: import('.').CopperOptions;
    fileList: import('.').UploadFile[];
}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & import('vue').Plugin;
export declare const MtUploadImageOnlyLayout: {
    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
        fileList: {
            type: import('vue').PropType<import('.').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('.').CopperOptions>;
        };
    }>> & Readonly<{
        onRemove?: ((...args: any[]) => any) | undefined;
    }>, {
        choose(): void;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
        remove: (...args: any[]) => void;
    }, import('vue').PublicProps, {
        disabled: boolean;
        multiple: boolean;
        showTrigger: boolean;
        autoCropper: boolean;
        fileList: import('.').UploadFile[];
        onExceed: (files: File[]) => void;
    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
        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;
    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<import('vue').ExtractPropTypes<{
        fileList: {
            type: import('vue').PropType<import('.').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('.').CopperOptions>;
        };
    }>> & Readonly<{
        onRemove?: ((...args: any[]) => any) | undefined;
    }>, {
        choose(): void;
    }, {}, {}, {}, {
        disabled: boolean;
        multiple: boolean;
        showTrigger: boolean;
        autoCropper: boolean;
        fileList: import('.').UploadFile[];
        onExceed: (files: File[]) => void;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
    fileList: {
        type: import('vue').PropType<import('.').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('.').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: import('.').UploadFile[];
    onExceed: (files: File[]) => void;
}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
    $slots: Readonly<Record<string, any>> & Record<string, any>;
}) & import('vue').Plugin;
export default MtUpload;
export type * from './src/upload';
export { formatUploadFiles } from './src/upload';