import './style';
export * from './interface';
export declare const Upload: import("vue").ComponentOptions<import("vue").default, import("@vue/composition-api").ShallowUnwrapRef<{
    handlePasteFileChange: (e: ClipboardEvent) => void;
    commonDisplayFileProps: import("@vue/composition-api").ComputedRef<import("./interface").CommonDisplayFileProps>;
    dragProps: import("@vue/composition-api").ComputedRef<import("./hooks/useDrag").UploadDragEvents>;
    uploadClasses: import("@vue/composition-api").ComputedRef<(string | {
        [x: string]: boolean;
    })[]>;
    sizeOverLimitMessage: import("@vue/composition-api").Ref<string>;
    tDisabled: import("@vue/composition-api").ComputedRef<boolean>;
    icons: import("tdesign-icons-vue").GlobalIconConfig;
    t: <T>(pattern: T, ...args: any[]) => any;
    localeConfig: import("@vue/composition-api").ComputedRef<({} & import("..").UploadConfig) | ({} & {
        readonly sizeLimitMessage: "文件大小不能超过 {sizeLimit}";
        readonly cancelUploadText: "取消上传";
        readonly triggerUploadText: {
            readonly fileInput: "选择文件";
            readonly image: "点击上传图片";
            readonly normal: "点击上传";
            readonly reupload: "重新选择";
            readonly continueUpload: "继续选择";
            readonly delete: "删除";
            readonly uploading: "上传中";
        };
        readonly dragger: {
            readonly dragDropText: "释放鼠标";
            readonly draggingText: "拖拽到此区域";
            readonly clickAndDragText: "点击上方“选择文件”或将文件拖拽到此区域";
        };
        readonly file: {
            readonly fileNameText: "文件名";
            readonly fileSizeText: "文件大小";
            readonly fileStatusText: "状态";
            readonly fileOperationText: "操作";
            readonly fileOperationDateText: "上传日期";
        };
        readonly progress: {
            readonly uploadingText: "上传中";
            readonly waitingText: "待上传";
            readonly failText: "上传失败";
            readonly successText: "上传成功";
        };
    } & import("..").UploadConfig)>;
    classPrefix: import("@vue/composition-api").Ref<string>;
    triggerUploadText: import("@vue/composition-api").ComputedRef<any>;
    toUploadFiles: import("@vue/composition-api").Ref<{
        [x: string]: any;
        lastModified?: number;
        name?: string;
        percent?: number;
        raw?: File;
        response?: {
            [x: string]: any;
        };
        size?: number;
        status?: "progress" | "waiting" | "success" | "fail";
        type?: string;
        uploadTime?: string;
        url?: string;
    }[]>;
    uploadValue: import("@vue/composition-api").Ref<import("./type").UploadFile[]>;
    displayFiles: import("@vue/composition-api").ComputedRef<import("../_common/js/upload/types").UploadFile[]>;
    uploading: import("@vue/composition-api").Ref<boolean>;
    tipsClasses: string;
    errorClasses: string[];
    placeholderClass: string;
    inputRef: import("@vue/composition-api").Ref<HTMLInputElement>;
    innerDisabled: import("@vue/composition-api").ComputedRef<boolean>;
    xhrReq: import("@vue/composition-api").Ref<{
        files: {
            [x: string]: any;
            lastModified?: number;
            name?: string;
            percent?: number;
            raw?: File;
            response?: {
                [x: string]: any;
            };
            size?: number;
            status?: "progress" | "waiting" | "success" | "fail";
            type?: string;
            uploadTime?: string;
            url?: string;
        }[];
        xhrReq: {
            onreadystatechange: (this: XMLHttpRequest, ev: Event) => any;
            readonly readyState: number;
            readonly response: any;
            readonly responseText: string;
            responseType: XMLHttpRequestResponseType;
            readonly responseURL: string;
            readonly responseXML: Document;
            readonly status: number;
            readonly statusText: string;
            timeout: number;
            readonly upload: {
                addEventListener: {
                    <K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestUpload, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
                };
                removeEventListener: {
                    <K_1 extends keyof XMLHttpRequestEventTargetEventMap>(type: K_1, listener: (this: XMLHttpRequestUpload, ev: XMLHttpRequestEventTargetEventMap[K_1]) => any, options?: boolean | EventListenerOptions): void;
                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
                };
                onabort: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
                onerror: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
                onload: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
                onloadend: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
                onloadstart: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
                onprogress: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
                ontimeout: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
                dispatchEvent: (event: Event) => boolean;
            };
            withCredentials: boolean;
            abort: () => void;
            getAllResponseHeaders: () => string;
            getResponseHeader: (name: string) => string;
            open: {
                (method: string, url: string | URL): void;
                (method: string, url: string | URL, async: boolean, username?: string, password?: string): void;
            };
            overrideMimeType: (mime: string) => void;
            send: (body?: Document | XMLHttpRequestBodyInit) => void;
            setRequestHeader: (name: string, value: string) => void;
            readonly DONE: number;
            readonly HEADERS_RECEIVED: number;
            readonly LOADING: number;
            readonly OPENED: number;
            readonly UNSENT: number;
            addEventListener: {
                <K_2 extends keyof XMLHttpRequestEventMap>(type: K_2, listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K_2]) => any, options?: boolean | AddEventListenerOptions): void;
                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
            };
            removeEventListener: {
                <K_3 extends keyof XMLHttpRequestEventMap>(type: K_3, listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K_3]) => any, options?: boolean | EventListenerOptions): void;
                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
            };
            onabort: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
            onerror: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
            onload: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
            onloadend: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
            onloadstart: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
            onprogress: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
            ontimeout: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
            dispatchEvent: (event: Event) => boolean;
        };
    }[]>;
    uploadFiles: (toFiles?: import("./type").UploadFile[]) => void;
    uploadFilePercent: (params: {
        file: import("./type").UploadFile;
        percent: number;
    }) => void;
    onFileChange: (files: File[]) => void;
    onNormalFileChange: (e: InputEvent) => void;
    onDragFileChange: (files: File[]) => void;
    onInnerRemove: (p: import("./type").UploadRemoveContext) => void;
    triggerUpload: (e?: MouseEvent) => void;
    cancelUpload: (context?: {
        file?: import("./type").UploadFile;
        e?: MouseEvent;
    }) => void;
    onInnerPreview: (p: {
        file: import("./type").UploadFile;
        index: number;
        e: MouseEvent;
    }) => void;
    innerCancelUpload: () => void;
    onPasteFileChange: (e: ClipboardEvent) => void;
}> & import("@vue/composition-api").Data, {
    renderTrigger(): any;
    getNormalFileNode(): JSX.Element;
    getSingleFileDraggerUploadNode(): JSX.Element;
    getImageCardUploadNode(): JSX.Element;
    getFlowListNode(): JSX.Element;
    getCustomFile(): JSX.Element;
}, {}, {
    abridgeName: {
        type: import("vue").PropType<number[]>;
    };
    accept: {
        type: StringConstructor;
        default: string;
    };
    action: {
        type: StringConstructor;
        default: string;
    };
    allowUploadDuplicateFile: BooleanConstructor;
    autoUpload: {
        type: BooleanConstructor;
        default: boolean;
    };
    beforeAllFilesUpload: {
        type: import("vue").PropType<(file: import("./type").UploadFile[]) => boolean | Promise<boolean>>;
    };
    beforeUpload: {
        type: import("vue").PropType<(file: import("./type").UploadFile) => boolean | Promise<boolean>>;
    };
    cancelUploadButton: {
        type: import("vue").PropType<import("..").TdButtonProps | ((h: import("vue").CreateElement, props: {
            disabled: boolean;
            cancelUploadText: string;
            cancelUpload: (ctx: {
                e: MouseEvent;
            }) => void;
        }) => import("vue/types/vnode").ScopedSlotReturnValue)>;
    };
    data: {
        type: import("vue").PropType<Record<string, any> | ((files: import("./type").UploadFile[]) => Record<string, any>)>;
    };
    default: {
        type: import("vue").PropType<string | ((h: import("vue").CreateElement) => import("vue/types/vnode").ScopedSlotReturnValue)>;
    };
    disabled: BooleanConstructor;
    dragContent: {
        type: import("vue").PropType<((h: import("vue").CreateElement) => import("vue/types/vnode").ScopedSlotReturnValue) | ((h: import("vue").CreateElement, props: import("./type").TriggerContext) => import("vue/types/vnode").ScopedSlotReturnValue)>;
    };
    draggable: {
        type: BooleanConstructor;
        default: any;
    };
    fileListDisplay: {
        type: import("vue").PropType<(h: import("vue").CreateElement, props: {
            files: import("./type").UploadFile[];
            dragEvents?: import("..").UploadDisplayDragEvents;
        }) => import("vue/types/vnode").ScopedSlotReturnValue>;
    };
    files: {
        type: import("vue").PropType<import("./type").UploadFile[]>;
        default: any;
    };
    defaultFiles: {
        type: import("vue").PropType<import("./type").UploadFile[]>;
        default: () => import("./type").UploadFile[];
    };
    format: {
        type: import("vue").PropType<(file: File) => import("./type").UploadFile>;
    };
    formatRequest: {
        type: import("vue").PropType<(requestData: {
            [key: string]: any;
        }) => {
            [key: string]: any;
        }>;
    };
    formatResponse: {
        type: import("vue").PropType<(response: any, context: import("./type").FormatResponseContext) => import("./type").ResponseType>;
    };
    headers: {
        type: import("vue").PropType<{
            [key: string]: string;
        }>;
    };
    imageViewerProps: {
        type: import("vue").PropType<import("..").TdImageViewerProps>;
    };
    inputAttributes: {
        type: import("vue").PropType<object>;
    };
    isBatchUpload: BooleanConstructor;
    locale: {
        type: import("vue").PropType<import("..").UploadConfig>;
    };
    max: {
        type: NumberConstructor;
        default: number;
    };
    method: {
        type: import("vue").PropType<"options" | "get" | "post" | "POST" | "GET" | "PUT" | "OPTIONS" | "PATCH" | "put" | "patch">;
        default: "options" | "get" | "post" | "POST" | "GET" | "PUT" | "OPTIONS" | "PATCH" | "put" | "patch";
        validator(val: "options" | "get" | "post" | "POST" | "GET" | "PUT" | "OPTIONS" | "PATCH" | "put" | "patch"): boolean;
    };
    mockProgressDuration: {
        type: NumberConstructor;
    };
    multiple: BooleanConstructor;
    name: {
        type: StringConstructor;
        default: string;
    };
    placeholder: {
        type: StringConstructor;
        default: string;
    };
    requestMethod: {
        type: import("vue").PropType<(files: import("./type").UploadFile | import("./type").UploadFile[]) => Promise<import("./type").RequestMethodResponse>>;
    };
    showImageFileName: {
        type: BooleanConstructor;
        default: boolean;
    };
    showThumbnail: BooleanConstructor;
    showUploadProgress: {
        type: BooleanConstructor;
        default: boolean;
    };
    sizeLimit: {
        type: import("vue").PropType<number | import("./type").SizeLimitObj>;
    };
    status: {
        type: import("vue").PropType<"error" | "default" | "success" | "warning">;
        validator(val: "error" | "default" | "success" | "warning"): boolean;
    };
    theme: {
        type: import("vue").PropType<"file" | "custom" | "image" | "file-input" | "file-flow" | "image-flow">;
        default: "file" | "custom" | "image" | "file-input" | "file-flow" | "image-flow";
        validator(val: "file" | "custom" | "image" | "file-input" | "file-flow" | "image-flow"): boolean;
    };
    tips: {
        type: import("vue").PropType<string | ((h: import("vue").CreateElement) => import("vue/types/vnode").ScopedSlotReturnValue)>;
    };
    trigger: {
        type: import("vue").PropType<(h: import("vue").CreateElement, props: import("./type").TriggerContext) => import("vue/types/vnode").ScopedSlotReturnValue>;
    };
    triggerButtonProps: {
        type: import("vue").PropType<import("..").TdButtonProps>;
    };
    uploadAllFilesInOneRequest: BooleanConstructor;
    uploadButton: {
        type: import("vue").PropType<import("..").TdButtonProps | ((h: import("vue").CreateElement, props: {
            disabled: boolean;
            uploading: boolean;
            uploadFiles: () => void;
            uploadText: string;
        }) => import("vue/types/vnode").ScopedSlotReturnValue)>;
    };
    uploadPastedFiles: {
        type: BooleanConstructor;
        default: boolean;
    };
    useMockProgress: {
        type: BooleanConstructor;
        default: boolean;
    };
    value: {
        type: import("vue").PropType<import("./type").UploadFile[]>;
        default: any;
    };
    defaultValue: {
        type: import("vue").PropType<import("./type").UploadFile[]>;
        default: () => import("./type").UploadFile[];
    };
    withCredentials: BooleanConstructor;
    onCancelUpload: import("vue").PropType<() => void>;
    onChange: import("vue").PropType<(value: import("./type").UploadFile[], context: import("./type").UploadChangeContext) => void>;
    onDragenter: import("vue").PropType<(context: {
        e: DragEvent;
    }) => void>;
    onDragleave: import("vue").PropType<(context: {
        e: DragEvent;
    }) => void>;
    onDrop: import("vue").PropType<(context: {
        e: DragEvent;
    }) => void>;
    onFail: import("vue").PropType<(options: import("./type").UploadFailContext) => void>;
    onOneFileFail: import("vue").PropType<(options: import("./type").UploadFailContext) => void>;
    onOneFileSuccess: import("vue").PropType<(context: Pick<import("./type").SuccessContext, "file" | "response" | "e" | "XMLHttpRequest">) => void>;
    onPreview: import("vue").PropType<(options: {
        file: import("./type").UploadFile;
        index: number;
        e: MouseEvent;
    }) => void>;
    onProgress: import("vue").PropType<(options: import("./type").ProgressContext) => void>;
    onRemove: import("vue").PropType<(context: import("./type").UploadRemoveContext) => void>;
    onSelectChange: import("vue").PropType<(files: File[], context: import("./type").UploadSelectChangeContext) => void>;
    onSuccess: import("vue").PropType<(context: import("./type").SuccessContext) => void>;
    onValidate: import("vue").PropType<(context: {
        type: import("./type").UploadValidateType;
        files: import("./type").UploadFile[];
    }) => void>;
    onWaitingUploadFilesChange: import("vue").PropType<(context: {
        files: import("./type").UploadFile[];
        trigger: "remove" | "validate" | "uploaded";
    }) => void>;
}, import("@vue/composition-api").ExtractPropTypes<{
    abridgeName: {
        type: import("vue").PropType<number[]>;
    };
    accept: {
        type: StringConstructor;
        default: string;
    };
    action: {
        type: StringConstructor;
        default: string;
    };
    allowUploadDuplicateFile: BooleanConstructor;
    autoUpload: {
        type: BooleanConstructor;
        default: boolean;
    };
    beforeAllFilesUpload: {
        type: import("vue").PropType<(file: import("./type").UploadFile[]) => boolean | Promise<boolean>>;
    };
    beforeUpload: {
        type: import("vue").PropType<(file: import("./type").UploadFile) => boolean | Promise<boolean>>;
    };
    cancelUploadButton: {
        type: import("vue").PropType<import("..").TdButtonProps | ((h: import("vue").CreateElement, props: {
            disabled: boolean;
            cancelUploadText: string;
            cancelUpload: (ctx: {
                e: MouseEvent;
            }) => void;
        }) => import("vue/types/vnode").ScopedSlotReturnValue)>;
    };
    data: {
        type: import("vue").PropType<Record<string, any> | ((files: import("./type").UploadFile[]) => Record<string, any>)>;
    };
    default: {
        type: import("vue").PropType<string | ((h: import("vue").CreateElement) => import("vue/types/vnode").ScopedSlotReturnValue)>;
    };
    disabled: BooleanConstructor;
    dragContent: {
        type: import("vue").PropType<((h: import("vue").CreateElement) => import("vue/types/vnode").ScopedSlotReturnValue) | ((h: import("vue").CreateElement, props: import("./type").TriggerContext) => import("vue/types/vnode").ScopedSlotReturnValue)>;
    };
    draggable: {
        type: BooleanConstructor;
        default: any;
    };
    fileListDisplay: {
        type: import("vue").PropType<(h: import("vue").CreateElement, props: {
            files: import("./type").UploadFile[];
            dragEvents?: import("..").UploadDisplayDragEvents;
        }) => import("vue/types/vnode").ScopedSlotReturnValue>;
    };
    files: {
        type: import("vue").PropType<import("./type").UploadFile[]>;
        default: any;
    };
    defaultFiles: {
        type: import("vue").PropType<import("./type").UploadFile[]>;
        default: () => import("./type").UploadFile[];
    };
    format: {
        type: import("vue").PropType<(file: File) => import("./type").UploadFile>;
    };
    formatRequest: {
        type: import("vue").PropType<(requestData: {
            [key: string]: any;
        }) => {
            [key: string]: any;
        }>;
    };
    formatResponse: {
        type: import("vue").PropType<(response: any, context: import("./type").FormatResponseContext) => import("./type").ResponseType>;
    };
    headers: {
        type: import("vue").PropType<{
            [key: string]: string;
        }>;
    };
    imageViewerProps: {
        type: import("vue").PropType<import("..").TdImageViewerProps>;
    };
    inputAttributes: {
        type: import("vue").PropType<object>;
    };
    isBatchUpload: BooleanConstructor;
    locale: {
        type: import("vue").PropType<import("..").UploadConfig>;
    };
    max: {
        type: NumberConstructor;
        default: number;
    };
    method: {
        type: import("vue").PropType<"options" | "get" | "post" | "POST" | "GET" | "PUT" | "OPTIONS" | "PATCH" | "put" | "patch">;
        default: "options" | "get" | "post" | "POST" | "GET" | "PUT" | "OPTIONS" | "PATCH" | "put" | "patch";
        validator(val: "options" | "get" | "post" | "POST" | "GET" | "PUT" | "OPTIONS" | "PATCH" | "put" | "patch"): boolean;
    };
    mockProgressDuration: {
        type: NumberConstructor;
    };
    multiple: BooleanConstructor;
    name: {
        type: StringConstructor;
        default: string;
    };
    placeholder: {
        type: StringConstructor;
        default: string;
    };
    requestMethod: {
        type: import("vue").PropType<(files: import("./type").UploadFile | import("./type").UploadFile[]) => Promise<import("./type").RequestMethodResponse>>;
    };
    showImageFileName: {
        type: BooleanConstructor;
        default: boolean;
    };
    showThumbnail: BooleanConstructor;
    showUploadProgress: {
        type: BooleanConstructor;
        default: boolean;
    };
    sizeLimit: {
        type: import("vue").PropType<number | import("./type").SizeLimitObj>;
    };
    status: {
        type: import("vue").PropType<"error" | "default" | "success" | "warning">;
        validator(val: "error" | "default" | "success" | "warning"): boolean;
    };
    theme: {
        type: import("vue").PropType<"file" | "custom" | "image" | "file-input" | "file-flow" | "image-flow">;
        default: "file" | "custom" | "image" | "file-input" | "file-flow" | "image-flow";
        validator(val: "file" | "custom" | "image" | "file-input" | "file-flow" | "image-flow"): boolean;
    };
    tips: {
        type: import("vue").PropType<string | ((h: import("vue").CreateElement) => import("vue/types/vnode").ScopedSlotReturnValue)>;
    };
    trigger: {
        type: import("vue").PropType<(h: import("vue").CreateElement, props: import("./type").TriggerContext) => import("vue/types/vnode").ScopedSlotReturnValue>;
    };
    triggerButtonProps: {
        type: import("vue").PropType<import("..").TdButtonProps>;
    };
    uploadAllFilesInOneRequest: BooleanConstructor;
    uploadButton: {
        type: import("vue").PropType<import("..").TdButtonProps | ((h: import("vue").CreateElement, props: {
            disabled: boolean;
            uploading: boolean;
            uploadFiles: () => void;
            uploadText: string;
        }) => import("vue/types/vnode").ScopedSlotReturnValue)>;
    };
    uploadPastedFiles: {
        type: BooleanConstructor;
        default: boolean;
    };
    useMockProgress: {
        type: BooleanConstructor;
        default: boolean;
    };
    value: {
        type: import("vue").PropType<import("./type").UploadFile[]>;
        default: any;
    };
    defaultValue: {
        type: import("vue").PropType<import("./type").UploadFile[]>;
        default: () => import("./type").UploadFile[];
    };
    withCredentials: BooleanConstructor;
    onCancelUpload: import("vue").PropType<() => void>;
    onChange: import("vue").PropType<(value: import("./type").UploadFile[], context: import("./type").UploadChangeContext) => void>;
    onDragenter: import("vue").PropType<(context: {
        e: DragEvent;
    }) => void>;
    onDragleave: import("vue").PropType<(context: {
        e: DragEvent;
    }) => void>;
    onDrop: import("vue").PropType<(context: {
        e: DragEvent;
    }) => void>;
    onFail: import("vue").PropType<(options: import("./type").UploadFailContext) => void>;
    onOneFileFail: import("vue").PropType<(options: import("./type").UploadFailContext) => void>;
    onOneFileSuccess: import("vue").PropType<(context: Pick<import("./type").SuccessContext, "file" | "response" | "e" | "XMLHttpRequest">) => void>;
    onPreview: import("vue").PropType<(options: {
        file: import("./type").UploadFile;
        index: number;
        e: MouseEvent;
    }) => void>;
    onProgress: import("vue").PropType<(options: import("./type").ProgressContext) => void>;
    onRemove: import("vue").PropType<(context: import("./type").UploadRemoveContext) => void>;
    onSelectChange: import("vue").PropType<(files: File[], context: import("./type").UploadSelectChangeContext) => void>;
    onSuccess: import("vue").PropType<(context: import("./type").SuccessContext) => void>;
    onValidate: import("vue").PropType<(context: {
        type: import("./type").UploadValidateType;
        files: import("./type").UploadFile[];
    }) => void>;
    onWaitingUploadFilesChange: import("vue").PropType<(context: {
        files: import("./type").UploadFile[];
        trigger: "remove" | "validate" | "uploaded";
    }) => void>;
}>> & Omit<import("vue").VueConstructor<import("vue").default>, never> & (new (...args: any[]) => import("@vue/composition-api").ComponentRenderProxy<{
    max: number;
    name: string;
    value: import("./type").UploadFile[];
    action: string;
    method: "options" | "get" | "post" | "POST" | "GET" | "PUT" | "OPTIONS" | "PATCH" | "put" | "patch";
    draggable: boolean;
    disabled: boolean;
    multiple: boolean;
    theme: "file" | "custom" | "image" | "file-input" | "file-flow" | "image-flow";
    defaultValue: import("./type").UploadFile[];
    placeholder: string;
    files: import("./type").UploadFile[];
    defaultFiles: import("./type").UploadFile[];
    accept: string;
    autoUpload: boolean;
    showUploadProgress: boolean;
    showImageFileName: boolean;
    isBatchUpload: boolean;
    showThumbnail: boolean;
    withCredentials: boolean;
    useMockProgress: boolean;
    uploadAllFilesInOneRequest: boolean;
    allowUploadDuplicateFile: boolean;
    uploadPastedFiles: boolean;
} & {
    data?: unknown;
    default?: string | ((h: import("vue").CreateElement) => import("vue/types/vnode").ScopedSlotReturnValue);
    status?: "error" | "default" | "success" | "warning";
    onChange?: (value: import("./type").UploadFile[], context: import("./type").UploadChangeContext) => void;
    formatResponse?: (response: any, context: import("./type").FormatResponseContext) => import("./type").ResponseType;
    format?: (file: File) => import("./type").UploadFile;
    tips?: string | ((h: import("vue").CreateElement) => import("vue/types/vnode").ScopedSlotReturnValue);
    onValidate?: (context: {
        type: import("./type").UploadValidateType;
        files: import("./type").UploadFile[];
    }) => void;
    trigger?: (h: import("vue").CreateElement, props: import("./type").TriggerContext) => import("vue/types/vnode").ScopedSlotReturnValue;
    onRemove?: (context: import("./type").UploadRemoveContext) => void;
    onDrop?: (context: {
        e: DragEvent;
    }) => void;
    locale?: unknown;
    onSelectChange?: (files: File[], context: import("./type").UploadSelectChangeContext) => void;
    abridgeName?: number[];
    beforeAllFilesUpload?: (file: import("./type").UploadFile[]) => boolean | Promise<boolean>;
    beforeUpload?: (file: import("./type").UploadFile) => boolean | Promise<boolean>;
    cancelUploadButton?: unknown;
    dragContent?: ((h: import("vue").CreateElement) => import("vue/types/vnode").ScopedSlotReturnValue) | ((h: import("vue").CreateElement, props: import("./type").TriggerContext) => import("vue/types/vnode").ScopedSlotReturnValue);
    fileListDisplay?: (h: import("vue").CreateElement, props: {
        files: import("./type").UploadFile[];
        dragEvents?: import("..").UploadDisplayDragEvents;
    }) => import("vue/types/vnode").ScopedSlotReturnValue;
    formatRequest?: (requestData: {
        [key: string]: any;
    }) => {
        [key: string]: any;
    };
    headers?: {
        [key: string]: string;
    };
    imageViewerProps?: unknown;
    inputAttributes?: object;
    requestMethod?: (files: import("./type").UploadFile | import("./type").UploadFile[]) => Promise<import("./type").RequestMethodResponse>;
    sizeLimit?: number | import("./type").SizeLimitObj;
    triggerButtonProps?: unknown;
    uploadButton?: unknown;
    onCancelUpload?: () => void;
    onDragenter?: (context: {
        e: DragEvent;
    }) => void;
    onDragleave?: (context: {
        e: DragEvent;
    }) => void;
    onFail?: (options: import("./type").UploadFailContext) => void;
    onOneFileFail?: (options: import("./type").UploadFailContext) => void;
    onOneFileSuccess?: (context: Pick<import("./type").SuccessContext, "file" | "response" | "e" | "XMLHttpRequest">) => void;
    onPreview?: (options: {
        file: import("./type").UploadFile;
        index: number;
        e: MouseEvent;
    }) => void;
    onProgress?: (options: import("./type").ProgressContext) => void;
    onSuccess?: (context: import("./type").SuccessContext) => void;
    onWaitingUploadFilesChange?: (context: {
        files: import("./type").UploadFile[];
        trigger: "remove" | "validate" | "uploaded";
    }) => void;
    mockProgressDuration?: number;
}, import("@vue/composition-api").ShallowUnwrapRef<{
    handlePasteFileChange: (e: ClipboardEvent) => void;
    commonDisplayFileProps: import("@vue/composition-api").ComputedRef<import("./interface").CommonDisplayFileProps>;
    dragProps: import("@vue/composition-api").ComputedRef<import("./hooks/useDrag").UploadDragEvents>;
    uploadClasses: import("@vue/composition-api").ComputedRef<(string | {
        [x: string]: boolean;
    })[]>;
    sizeOverLimitMessage: import("@vue/composition-api").Ref<string>;
    tDisabled: import("@vue/composition-api").ComputedRef<boolean>;
    icons: import("tdesign-icons-vue").GlobalIconConfig;
    t: <T>(pattern: T, ...args: any[]) => any;
    localeConfig: import("@vue/composition-api").ComputedRef<({} & import("..").UploadConfig) | ({} & {
        readonly sizeLimitMessage: "文件大小不能超过 {sizeLimit}";
        readonly cancelUploadText: "取消上传";
        readonly triggerUploadText: {
            readonly fileInput: "选择文件";
            readonly image: "点击上传图片";
            readonly normal: "点击上传";
            readonly reupload: "重新选择";
            readonly continueUpload: "继续选择";
            readonly delete: "删除";
            readonly uploading: "上传中";
        };
        readonly dragger: {
            readonly dragDropText: "释放鼠标";
            readonly draggingText: "拖拽到此区域";
            readonly clickAndDragText: "点击上方“选择文件”或将文件拖拽到此区域";
        };
        readonly file: {
            readonly fileNameText: "文件名";
            readonly fileSizeText: "文件大小";
            readonly fileStatusText: "状态";
            readonly fileOperationText: "操作";
            readonly fileOperationDateText: "上传日期";
        };
        readonly progress: {
            readonly uploadingText: "上传中";
            readonly waitingText: "待上传";
            readonly failText: "上传失败";
            readonly successText: "上传成功";
        };
    } & import("..").UploadConfig)>;
    classPrefix: import("@vue/composition-api").Ref<string>;
    triggerUploadText: import("@vue/composition-api").ComputedRef<any>;
    toUploadFiles: import("@vue/composition-api").Ref<{
        [x: string]: any;
        lastModified?: number;
        name?: string;
        percent?: number;
        raw?: File;
        response?: {
            [x: string]: any;
        };
        size?: number;
        status?: "progress" | "waiting" | "success" | "fail";
        type?: string;
        uploadTime?: string;
        url?: string;
    }[]>;
    uploadValue: import("@vue/composition-api").Ref<import("./type").UploadFile[]>;
    displayFiles: import("@vue/composition-api").ComputedRef<import("../_common/js/upload/types").UploadFile[]>;
    uploading: import("@vue/composition-api").Ref<boolean>;
    tipsClasses: string;
    errorClasses: string[];
    placeholderClass: string;
    inputRef: import("@vue/composition-api").Ref<HTMLInputElement>;
    innerDisabled: import("@vue/composition-api").ComputedRef<boolean>;
    xhrReq: import("@vue/composition-api").Ref<{
        files: {
            [x: string]: any;
            lastModified?: number;
            name?: string;
            percent?: number;
            raw?: File;
            response?: {
                [x: string]: any;
            };
            size?: number;
            status?: "progress" | "waiting" | "success" | "fail";
            type?: string;
            uploadTime?: string;
            url?: string;
        }[];
        xhrReq: {
            onreadystatechange: (this: XMLHttpRequest, ev: Event) => any;
            readonly readyState: number;
            readonly response: any;
            readonly responseText: string;
            responseType: XMLHttpRequestResponseType;
            readonly responseURL: string;
            readonly responseXML: Document;
            readonly status: number;
            readonly statusText: string;
            timeout: number;
            readonly upload: {
                addEventListener: {
                    <K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestUpload, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
                };
                removeEventListener: {
                    <K_1 extends keyof XMLHttpRequestEventTargetEventMap>(type: K_1, listener: (this: XMLHttpRequestUpload, ev: XMLHttpRequestEventTargetEventMap[K_1]) => any, options?: boolean | EventListenerOptions): void;
                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
                };
                onabort: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
                onerror: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
                onload: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
                onloadend: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
                onloadstart: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
                onprogress: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
                ontimeout: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
                dispatchEvent: (event: Event) => boolean;
            };
            withCredentials: boolean;
            abort: () => void;
            getAllResponseHeaders: () => string;
            getResponseHeader: (name: string) => string;
            open: {
                (method: string, url: string | URL): void;
                (method: string, url: string | URL, async: boolean, username?: string, password?: string): void;
            };
            overrideMimeType: (mime: string) => void;
            send: (body?: Document | XMLHttpRequestBodyInit) => void;
            setRequestHeader: (name: string, value: string) => void;
            readonly DONE: number;
            readonly HEADERS_RECEIVED: number;
            readonly LOADING: number;
            readonly OPENED: number;
            readonly UNSENT: number;
            addEventListener: {
                <K_2 extends keyof XMLHttpRequestEventMap>(type: K_2, listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K_2]) => any, options?: boolean | AddEventListenerOptions): void;
                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
            };
            removeEventListener: {
                <K_3 extends keyof XMLHttpRequestEventMap>(type: K_3, listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K_3]) => any, options?: boolean | EventListenerOptions): void;
                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
            };
            onabort: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
            onerror: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
            onload: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
            onloadend: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
            onloadstart: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
            onprogress: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
            ontimeout: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
            dispatchEvent: (event: Event) => boolean;
        };
    }[]>;
    uploadFiles: (toFiles?: import("./type").UploadFile[]) => void;
    uploadFilePercent: (params: {
        file: import("./type").UploadFile;
        percent: number;
    }) => void;
    onFileChange: (files: File[]) => void;
    onNormalFileChange: (e: InputEvent) => void;
    onDragFileChange: (files: File[]) => void;
    onInnerRemove: (p: import("./type").UploadRemoveContext) => void;
    triggerUpload: (e?: MouseEvent) => void;
    cancelUpload: (context?: {
        file?: import("./type").UploadFile;
        e?: MouseEvent;
    }) => void;
    onInnerPreview: (p: {
        file: import("./type").UploadFile;
        index: number;
        e: MouseEvent;
    }) => void;
    innerCancelUpload: () => void;
    onPasteFileChange: (e: ClipboardEvent) => void;
}>, import("@vue/composition-api").Data, {}, {
    renderTrigger(): any;
    getNormalFileNode(): JSX.Element;
    getSingleFileDraggerUploadNode(): JSX.Element;
    getImageCardUploadNode(): JSX.Element;
    getFlowListNode(): JSX.Element;
    getCustomFile(): JSX.Element;
}, {}, {}, {}, {
    max: number;
    name: string;
    value: import("./type").UploadFile[];
    action: string;
    method: "options" | "get" | "post" | "POST" | "GET" | "PUT" | "OPTIONS" | "PATCH" | "put" | "patch";
    draggable: boolean;
    disabled: boolean;
    multiple: boolean;
    theme: "file" | "custom" | "image" | "file-input" | "file-flow" | "image-flow";
    defaultValue: import("./type").UploadFile[];
    placeholder: string;
    files: import("./type").UploadFile[];
    defaultFiles: import("./type").UploadFile[];
    accept: string;
    autoUpload: boolean;
    showUploadProgress: boolean;
    showImageFileName: boolean;
    isBatchUpload: boolean;
    showThumbnail: boolean;
    withCredentials: boolean;
    useMockProgress: boolean;
    uploadAllFilesInOneRequest: boolean;
    allowUploadDuplicateFile: boolean;
    uploadPastedFiles: boolean;
} & {
    data?: unknown;
    default?: string | ((h: import("vue").CreateElement) => import("vue/types/vnode").ScopedSlotReturnValue);
    status?: "error" | "default" | "success" | "warning";
    onChange?: (value: import("./type").UploadFile[], context: import("./type").UploadChangeContext) => void;
    formatResponse?: (response: any, context: import("./type").FormatResponseContext) => import("./type").ResponseType;
    format?: (file: File) => import("./type").UploadFile;
    tips?: string | ((h: import("vue").CreateElement) => import("vue/types/vnode").ScopedSlotReturnValue);
    onValidate?: (context: {
        type: import("./type").UploadValidateType;
        files: import("./type").UploadFile[];
    }) => void;
    trigger?: (h: import("vue").CreateElement, props: import("./type").TriggerContext) => import("vue/types/vnode").ScopedSlotReturnValue;
    onRemove?: (context: import("./type").UploadRemoveContext) => void;
    onDrop?: (context: {
        e: DragEvent;
    }) => void;
    locale?: unknown;
    onSelectChange?: (files: File[], context: import("./type").UploadSelectChangeContext) => void;
    abridgeName?: number[];
    beforeAllFilesUpload?: (file: import("./type").UploadFile[]) => boolean | Promise<boolean>;
    beforeUpload?: (file: import("./type").UploadFile) => boolean | Promise<boolean>;
    cancelUploadButton?: unknown;
    dragContent?: ((h: import("vue").CreateElement) => import("vue/types/vnode").ScopedSlotReturnValue) | ((h: import("vue").CreateElement, props: import("./type").TriggerContext) => import("vue/types/vnode").ScopedSlotReturnValue);
    fileListDisplay?: (h: import("vue").CreateElement, props: {
        files: import("./type").UploadFile[];
        dragEvents?: import("..").UploadDisplayDragEvents;
    }) => import("vue/types/vnode").ScopedSlotReturnValue;
    formatRequest?: (requestData: {
        [key: string]: any;
    }) => {
        [key: string]: any;
    };
    headers?: {
        [key: string]: string;
    };
    imageViewerProps?: unknown;
    inputAttributes?: object;
    requestMethod?: (files: import("./type").UploadFile | import("./type").UploadFile[]) => Promise<import("./type").RequestMethodResponse>;
    sizeLimit?: number | import("./type").SizeLimitObj;
    triggerButtonProps?: unknown;
    uploadButton?: unknown;
    onCancelUpload?: () => void;
    onDragenter?: (context: {
        e: DragEvent;
    }) => void;
    onDragleave?: (context: {
        e: DragEvent;
    }) => void;
    onFail?: (options: import("./type").UploadFailContext) => void;
    onOneFileFail?: (options: import("./type").UploadFailContext) => void;
    onOneFileSuccess?: (context: Pick<import("./type").SuccessContext, "file" | "response" | "e" | "XMLHttpRequest">) => void;
    onPreview?: (options: {
        file: import("./type").UploadFile;
        index: number;
        e: MouseEvent;
    }) => void;
    onProgress?: (options: import("./type").ProgressContext) => void;
    onSuccess?: (context: import("./type").SuccessContext) => void;
    onWaitingUploadFilesChange?: (context: {
        files: import("./type").UploadFile[];
        trigger: "remove" | "validate" | "uploaded";
    }) => void;
    mockProgressDuration?: number;
}, {
    max: number;
    name: string;
    value: import("./type").UploadFile[];
    action: string;
    method: "options" | "get" | "post" | "POST" | "GET" | "PUT" | "OPTIONS" | "PATCH" | "put" | "patch";
    draggable: boolean;
    disabled: boolean;
    multiple: boolean;
    theme: "file" | "custom" | "image" | "file-input" | "file-flow" | "image-flow";
    defaultValue: import("./type").UploadFile[];
    placeholder: string;
    files: import("./type").UploadFile[];
    defaultFiles: import("./type").UploadFile[];
    accept: string;
    autoUpload: boolean;
    showUploadProgress: boolean;
    showImageFileName: boolean;
    isBatchUpload: boolean;
    showThumbnail: boolean;
    withCredentials: boolean;
    useMockProgress: boolean;
    uploadAllFilesInOneRequest: boolean;
    allowUploadDuplicateFile: boolean;
    uploadPastedFiles: boolean;
}, true>) & import("vue").PluginObject<import("vue").ComponentOptions<import("vue").default, import("@vue/composition-api").ShallowUnwrapRef<{
    handlePasteFileChange: (e: ClipboardEvent) => void;
    commonDisplayFileProps: import("@vue/composition-api").ComputedRef<import("./interface").CommonDisplayFileProps>;
    dragProps: import("@vue/composition-api").ComputedRef<import("./hooks/useDrag").UploadDragEvents>;
    uploadClasses: import("@vue/composition-api").ComputedRef<(string | {
        [x: string]: boolean;
    })[]>;
    sizeOverLimitMessage: import("@vue/composition-api").Ref<string>;
    tDisabled: import("@vue/composition-api").ComputedRef<boolean>;
    icons: import("tdesign-icons-vue").GlobalIconConfig;
    t: <T>(pattern: T, ...args: any[]) => any;
    localeConfig: import("@vue/composition-api").ComputedRef<({} & import("..").UploadConfig) | ({} & {
        readonly sizeLimitMessage: "文件大小不能超过 {sizeLimit}";
        readonly cancelUploadText: "取消上传";
        readonly triggerUploadText: {
            readonly fileInput: "选择文件";
            readonly image: "点击上传图片";
            readonly normal: "点击上传";
            readonly reupload: "重新选择";
            readonly continueUpload: "继续选择";
            readonly delete: "删除";
            readonly uploading: "上传中";
        };
        readonly dragger: {
            readonly dragDropText: "释放鼠标";
            readonly draggingText: "拖拽到此区域";
            readonly clickAndDragText: "点击上方“选择文件”或将文件拖拽到此区域";
        };
        readonly file: {
            readonly fileNameText: "文件名";
            readonly fileSizeText: "文件大小";
            readonly fileStatusText: "状态";
            readonly fileOperationText: "操作";
            readonly fileOperationDateText: "上传日期";
        };
        readonly progress: {
            readonly uploadingText: "上传中";
            readonly waitingText: "待上传";
            readonly failText: "上传失败";
            readonly successText: "上传成功";
        };
    } & import("..").UploadConfig)>;
    classPrefix: import("@vue/composition-api").Ref<string>;
    triggerUploadText: import("@vue/composition-api").ComputedRef<any>;
    toUploadFiles: import("@vue/composition-api").Ref<{
        [x: string]: any;
        lastModified?: number;
        name?: string;
        percent?: number;
        raw?: File;
        response?: {
            [x: string]: any;
        };
        size?: number;
        status?: "progress" | "waiting" | "success" | "fail";
        type?: string;
        uploadTime?: string;
        url?: string;
    }[]>;
    uploadValue: import("@vue/composition-api").Ref<import("./type").UploadFile[]>;
    displayFiles: import("@vue/composition-api").ComputedRef<import("../_common/js/upload/types").UploadFile[]>;
    uploading: import("@vue/composition-api").Ref<boolean>;
    tipsClasses: string;
    errorClasses: string[];
    placeholderClass: string;
    inputRef: import("@vue/composition-api").Ref<HTMLInputElement>;
    innerDisabled: import("@vue/composition-api").ComputedRef<boolean>;
    xhrReq: import("@vue/composition-api").Ref<{
        files: {
            [x: string]: any;
            lastModified?: number;
            name?: string;
            percent?: number;
            raw?: File;
            response?: {
                [x: string]: any;
            };
            size?: number;
            status?: "progress" | "waiting" | "success" | "fail";
            type?: string;
            uploadTime?: string;
            url?: string;
        }[];
        xhrReq: {
            onreadystatechange: (this: XMLHttpRequest, ev: Event) => any;
            readonly readyState: number;
            readonly response: any;
            readonly responseText: string;
            responseType: XMLHttpRequestResponseType;
            readonly responseURL: string;
            readonly responseXML: Document;
            readonly status: number;
            readonly statusText: string;
            timeout: number;
            readonly upload: {
                addEventListener: {
                    <K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestUpload, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
                };
                removeEventListener: {
                    <K_1 extends keyof XMLHttpRequestEventTargetEventMap>(type: K_1, listener: (this: XMLHttpRequestUpload, ev: XMLHttpRequestEventTargetEventMap[K_1]) => any, options?: boolean | EventListenerOptions): void;
                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
                };
                onabort: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
                onerror: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
                onload: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
                onloadend: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
                onloadstart: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
                onprogress: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
                ontimeout: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
                dispatchEvent: (event: Event) => boolean;
            };
            withCredentials: boolean;
            abort: () => void;
            getAllResponseHeaders: () => string;
            getResponseHeader: (name: string) => string;
            open: {
                (method: string, url: string | URL): void;
                (method: string, url: string | URL, async: boolean, username?: string, password?: string): void;
            };
            overrideMimeType: (mime: string) => void;
            send: (body?: Document | XMLHttpRequestBodyInit) => void;
            setRequestHeader: (name: string, value: string) => void;
            readonly DONE: number;
            readonly HEADERS_RECEIVED: number;
            readonly LOADING: number;
            readonly OPENED: number;
            readonly UNSENT: number;
            addEventListener: {
                <K_2 extends keyof XMLHttpRequestEventMap>(type: K_2, listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K_2]) => any, options?: boolean | AddEventListenerOptions): void;
                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
            };
            removeEventListener: {
                <K_3 extends keyof XMLHttpRequestEventMap>(type: K_3, listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K_3]) => any, options?: boolean | EventListenerOptions): void;
                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
            };
            onabort: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
            onerror: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
            onload: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
            onloadend: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
            onloadstart: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
            onprogress: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
            ontimeout: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
            dispatchEvent: (event: Event) => boolean;
        };
    }[]>;
    uploadFiles: (toFiles?: import("./type").UploadFile[]) => void;
    uploadFilePercent: (params: {
        file: import("./type").UploadFile;
        percent: number;
    }) => void;
    onFileChange: (files: File[]) => void;
    onNormalFileChange: (e: InputEvent) => void;
    onDragFileChange: (files: File[]) => void;
    onInnerRemove: (p: import("./type").UploadRemoveContext) => void;
    triggerUpload: (e?: MouseEvent) => void;
    cancelUpload: (context?: {
        file?: import("./type").UploadFile;
        e?: MouseEvent;
    }) => void;
    onInnerPreview: (p: {
        file: import("./type").UploadFile;
        index: number;
        e: MouseEvent;
    }) => void;
    innerCancelUpload: () => void;
    onPasteFileChange: (e: ClipboardEvent) => void;
}> & import("@vue/composition-api").Data, {
    renderTrigger(): any;
    getNormalFileNode(): JSX.Element;
    getSingleFileDraggerUploadNode(): JSX.Element;
    getImageCardUploadNode(): JSX.Element;
    getFlowListNode(): JSX.Element;
    getCustomFile(): JSX.Element;
}, {}, {
    abridgeName: {
        type: import("vue").PropType<number[]>;
    };
    accept: {
        type: StringConstructor;
        default: string;
    };
    action: {
        type: StringConstructor;
        default: string;
    };
    allowUploadDuplicateFile: BooleanConstructor;
    autoUpload: {
        type: BooleanConstructor;
        default: boolean;
    };
    beforeAllFilesUpload: {
        type: import("vue").PropType<(file: import("./type").UploadFile[]) => boolean | Promise<boolean>>;
    };
    beforeUpload: {
        type: import("vue").PropType<(file: import("./type").UploadFile) => boolean | Promise<boolean>>;
    };
    cancelUploadButton: {
        type: import("vue").PropType<import("..").TdButtonProps | ((h: import("vue").CreateElement, props: {
            disabled: boolean;
            cancelUploadText: string;
            cancelUpload: (ctx: {
                e: MouseEvent;
            }) => void;
        }) => import("vue/types/vnode").ScopedSlotReturnValue)>;
    };
    data: {
        type: import("vue").PropType<Record<string, any> | ((files: import("./type").UploadFile[]) => Record<string, any>)>;
    };
    default: {
        type: import("vue").PropType<string | ((h: import("vue").CreateElement) => import("vue/types/vnode").ScopedSlotReturnValue)>;
    };
    disabled: BooleanConstructor;
    dragContent: {
        type: import("vue").PropType<((h: import("vue").CreateElement) => import("vue/types/vnode").ScopedSlotReturnValue) | ((h: import("vue").CreateElement, props: import("./type").TriggerContext) => import("vue/types/vnode").ScopedSlotReturnValue)>;
    };
    draggable: {
        type: BooleanConstructor;
        default: any;
    };
    fileListDisplay: {
        type: import("vue").PropType<(h: import("vue").CreateElement, props: {
            files: import("./type").UploadFile[];
            dragEvents?: import("..").UploadDisplayDragEvents;
        }) => import("vue/types/vnode").ScopedSlotReturnValue>;
    };
    files: {
        type: import("vue").PropType<import("./type").UploadFile[]>;
        default: any;
    };
    defaultFiles: {
        type: import("vue").PropType<import("./type").UploadFile[]>;
        default: () => import("./type").UploadFile[];
    };
    format: {
        type: import("vue").PropType<(file: File) => import("./type").UploadFile>;
    };
    formatRequest: {
        type: import("vue").PropType<(requestData: {
            [key: string]: any;
        }) => {
            [key: string]: any;
        }>;
    };
    formatResponse: {
        type: import("vue").PropType<(response: any, context: import("./type").FormatResponseContext) => import("./type").ResponseType>;
    };
    headers: {
        type: import("vue").PropType<{
            [key: string]: string;
        }>;
    };
    imageViewerProps: {
        type: import("vue").PropType<import("..").TdImageViewerProps>;
    };
    inputAttributes: {
        type: import("vue").PropType<object>;
    };
    isBatchUpload: BooleanConstructor;
    locale: {
        type: import("vue").PropType<import("..").UploadConfig>;
    };
    max: {
        type: NumberConstructor;
        default: number;
    };
    method: {
        type: import("vue").PropType<"options" | "get" | "post" | "POST" | "GET" | "PUT" | "OPTIONS" | "PATCH" | "put" | "patch">;
        default: "options" | "get" | "post" | "POST" | "GET" | "PUT" | "OPTIONS" | "PATCH" | "put" | "patch";
        validator(val: "options" | "get" | "post" | "POST" | "GET" | "PUT" | "OPTIONS" | "PATCH" | "put" | "patch"): boolean;
    };
    mockProgressDuration: {
        type: NumberConstructor;
    };
    multiple: BooleanConstructor;
    name: {
        type: StringConstructor;
        default: string;
    };
    placeholder: {
        type: StringConstructor;
        default: string;
    };
    requestMethod: {
        type: import("vue").PropType<(files: import("./type").UploadFile | import("./type").UploadFile[]) => Promise<import("./type").RequestMethodResponse>>;
    };
    showImageFileName: {
        type: BooleanConstructor;
        default: boolean;
    };
    showThumbnail: BooleanConstructor;
    showUploadProgress: {
        type: BooleanConstructor;
        default: boolean;
    };
    sizeLimit: {
        type: import("vue").PropType<number | import("./type").SizeLimitObj>;
    };
    status: {
        type: import("vue").PropType<"error" | "default" | "success" | "warning">;
        validator(val: "error" | "default" | "success" | "warning"): boolean;
    };
    theme: {
        type: import("vue").PropType<"file" | "custom" | "image" | "file-input" | "file-flow" | "image-flow">;
        default: "file" | "custom" | "image" | "file-input" | "file-flow" | "image-flow";
        validator(val: "file" | "custom" | "image" | "file-input" | "file-flow" | "image-flow"): boolean;
    };
    tips: {
        type: import("vue").PropType<string | ((h: import("vue").CreateElement) => import("vue/types/vnode").ScopedSlotReturnValue)>;
    };
    trigger: {
        type: import("vue").PropType<(h: import("vue").CreateElement, props: import("./type").TriggerContext) => import("vue/types/vnode").ScopedSlotReturnValue>;
    };
    triggerButtonProps: {
        type: import("vue").PropType<import("..").TdButtonProps>;
    };
    uploadAllFilesInOneRequest: BooleanConstructor;
    uploadButton: {
        type: import("vue").PropType<import("..").TdButtonProps | ((h: import("vue").CreateElement, props: {
            disabled: boolean;
            uploading: boolean;
            uploadFiles: () => void;
            uploadText: string;
        }) => import("vue/types/vnode").ScopedSlotReturnValue)>;
    };
    uploadPastedFiles: {
        type: BooleanConstructor;
        default: boolean;
    };
    useMockProgress: {
        type: BooleanConstructor;
        default: boolean;
    };
    value: {
        type: import("vue").PropType<import("./type").UploadFile[]>;
        default: any;
    };
    defaultValue: {
        type: import("vue").PropType<import("./type").UploadFile[]>;
        default: () => import("./type").UploadFile[];
    };
    withCredentials: BooleanConstructor;
    onCancelUpload: import("vue").PropType<() => void>;
    onChange: import("vue").PropType<(value: import("./type").UploadFile[], context: import("./type").UploadChangeContext) => void>;
    onDragenter: import("vue").PropType<(context: {
        e: DragEvent;
    }) => void>;
    onDragleave: import("vue").PropType<(context: {
        e: DragEvent;
    }) => void>;
    onDrop: import("vue").PropType<(context: {
        e: DragEvent;
    }) => void>;
    onFail: import("vue").PropType<(options: import("./type").UploadFailContext) => void>;
    onOneFileFail: import("vue").PropType<(options: import("./type").UploadFailContext) => void>;
    onOneFileSuccess: import("vue").PropType<(context: Pick<import("./type").SuccessContext, "file" | "response" | "e" | "XMLHttpRequest">) => void>;
    onPreview: import("vue").PropType<(options: {
        file: import("./type").UploadFile;
        index: number;
        e: MouseEvent;
    }) => void>;
    onProgress: import("vue").PropType<(options: import("./type").ProgressContext) => void>;
    onRemove: import("vue").PropType<(context: import("./type").UploadRemoveContext) => void>;
    onSelectChange: import("vue").PropType<(files: File[], context: import("./type").UploadSelectChangeContext) => void>;
    onSuccess: import("vue").PropType<(context: import("./type").SuccessContext) => void>;
    onValidate: import("vue").PropType<(context: {
        type: import("./type").UploadValidateType;
        files: import("./type").UploadFile[];
    }) => void>;
    onWaitingUploadFilesChange: import("vue").PropType<(context: {
        files: import("./type").UploadFile[];
        trigger: "remove" | "validate" | "uploaded";
    }) => void>;
}, import("@vue/composition-api").ExtractPropTypes<{
    abridgeName: {
        type: import("vue").PropType<number[]>;
    };
    accept: {
        type: StringConstructor;
        default: string;
    };
    action: {
        type: StringConstructor;
        default: string;
    };
    allowUploadDuplicateFile: BooleanConstructor;
    autoUpload: {
        type: BooleanConstructor;
        default: boolean;
    };
    beforeAllFilesUpload: {
        type: import("vue").PropType<(file: import("./type").UploadFile[]) => boolean | Promise<boolean>>;
    };
    beforeUpload: {
        type: import("vue").PropType<(file: import("./type").UploadFile) => boolean | Promise<boolean>>;
    };
    cancelUploadButton: {
        type: import("vue").PropType<import("..").TdButtonProps | ((h: import("vue").CreateElement, props: {
            disabled: boolean;
            cancelUploadText: string;
            cancelUpload: (ctx: {
                e: MouseEvent;
            }) => void;
        }) => import("vue/types/vnode").ScopedSlotReturnValue)>;
    };
    data: {
        type: import("vue").PropType<Record<string, any> | ((files: import("./type").UploadFile[]) => Record<string, any>)>;
    };
    default: {
        type: import("vue").PropType<string | ((h: import("vue").CreateElement) => import("vue/types/vnode").ScopedSlotReturnValue)>;
    };
    disabled: BooleanConstructor;
    dragContent: {
        type: import("vue").PropType<((h: import("vue").CreateElement) => import("vue/types/vnode").ScopedSlotReturnValue) | ((h: import("vue").CreateElement, props: import("./type").TriggerContext) => import("vue/types/vnode").ScopedSlotReturnValue)>;
    };
    draggable: {
        type: BooleanConstructor;
        default: any;
    };
    fileListDisplay: {
        type: import("vue").PropType<(h: import("vue").CreateElement, props: {
            files: import("./type").UploadFile[];
            dragEvents?: import("..").UploadDisplayDragEvents;
        }) => import("vue/types/vnode").ScopedSlotReturnValue>;
    };
    files: {
        type: import("vue").PropType<import("./type").UploadFile[]>;
        default: any;
    };
    defaultFiles: {
        type: import("vue").PropType<import("./type").UploadFile[]>;
        default: () => import("./type").UploadFile[];
    };
    format: {
        type: import("vue").PropType<(file: File) => import("./type").UploadFile>;
    };
    formatRequest: {
        type: import("vue").PropType<(requestData: {
            [key: string]: any;
        }) => {
            [key: string]: any;
        }>;
    };
    formatResponse: {
        type: import("vue").PropType<(response: any, context: import("./type").FormatResponseContext) => import("./type").ResponseType>;
    };
    headers: {
        type: import("vue").PropType<{
            [key: string]: string;
        }>;
    };
    imageViewerProps: {
        type: import("vue").PropType<import("..").TdImageViewerProps>;
    };
    inputAttributes: {
        type: import("vue").PropType<object>;
    };
    isBatchUpload: BooleanConstructor;
    locale: {
        type: import("vue").PropType<import("..").UploadConfig>;
    };
    max: {
        type: NumberConstructor;
        default: number;
    };
    method: {
        type: import("vue").PropType<"options" | "get" | "post" | "POST" | "GET" | "PUT" | "OPTIONS" | "PATCH" | "put" | "patch">;
        default: "options" | "get" | "post" | "POST" | "GET" | "PUT" | "OPTIONS" | "PATCH" | "put" | "patch";
        validator(val: "options" | "get" | "post" | "POST" | "GET" | "PUT" | "OPTIONS" | "PATCH" | "put" | "patch"): boolean;
    };
    mockProgressDuration: {
        type: NumberConstructor;
    };
    multiple: BooleanConstructor;
    name: {
        type: StringConstructor;
        default: string;
    };
    placeholder: {
        type: StringConstructor;
        default: string;
    };
    requestMethod: {
        type: import("vue").PropType<(files: import("./type").UploadFile | import("./type").UploadFile[]) => Promise<import("./type").RequestMethodResponse>>;
    };
    showImageFileName: {
        type: BooleanConstructor;
        default: boolean;
    };
    showThumbnail: BooleanConstructor;
    showUploadProgress: {
        type: BooleanConstructor;
        default: boolean;
    };
    sizeLimit: {
        type: import("vue").PropType<number | import("./type").SizeLimitObj>;
    };
    status: {
        type: import("vue").PropType<"error" | "default" | "success" | "warning">;
        validator(val: "error" | "default" | "success" | "warning"): boolean;
    };
    theme: {
        type: import("vue").PropType<"file" | "custom" | "image" | "file-input" | "file-flow" | "image-flow">;
        default: "file" | "custom" | "image" | "file-input" | "file-flow" | "image-flow";
        validator(val: "file" | "custom" | "image" | "file-input" | "file-flow" | "image-flow"): boolean;
    };
    tips: {
        type: import("vue").PropType<string | ((h: import("vue").CreateElement) => import("vue/types/vnode").ScopedSlotReturnValue)>;
    };
    trigger: {
        type: import("vue").PropType<(h: import("vue").CreateElement, props: import("./type").TriggerContext) => import("vue/types/vnode").ScopedSlotReturnValue>;
    };
    triggerButtonProps: {
        type: import("vue").PropType<import("..").TdButtonProps>;
    };
    uploadAllFilesInOneRequest: BooleanConstructor;
    uploadButton: {
        type: import("vue").PropType<import("..").TdButtonProps | ((h: import("vue").CreateElement, props: {
            disabled: boolean;
            uploading: boolean;
            uploadFiles: () => void;
            uploadText: string;
        }) => import("vue/types/vnode").ScopedSlotReturnValue)>;
    };
    uploadPastedFiles: {
        type: BooleanConstructor;
        default: boolean;
    };
    useMockProgress: {
        type: BooleanConstructor;
        default: boolean;
    };
    value: {
        type: import("vue").PropType<import("./type").UploadFile[]>;
        default: any;
    };
    defaultValue: {
        type: import("vue").PropType<import("./type").UploadFile[]>;
        default: () => import("./type").UploadFile[];
    };
    withCredentials: BooleanConstructor;
    onCancelUpload: import("vue").PropType<() => void>;
    onChange: import("vue").PropType<(value: import("./type").UploadFile[], context: import("./type").UploadChangeContext) => void>;
    onDragenter: import("vue").PropType<(context: {
        e: DragEvent;
    }) => void>;
    onDragleave: import("vue").PropType<(context: {
        e: DragEvent;
    }) => void>;
    onDrop: import("vue").PropType<(context: {
        e: DragEvent;
    }) => void>;
    onFail: import("vue").PropType<(options: import("./type").UploadFailContext) => void>;
    onOneFileFail: import("vue").PropType<(options: import("./type").UploadFailContext) => void>;
    onOneFileSuccess: import("vue").PropType<(context: Pick<import("./type").SuccessContext, "file" | "response" | "e" | "XMLHttpRequest">) => void>;
    onPreview: import("vue").PropType<(options: {
        file: import("./type").UploadFile;
        index: number;
        e: MouseEvent;
    }) => void>;
    onProgress: import("vue").PropType<(options: import("./type").ProgressContext) => void>;
    onRemove: import("vue").PropType<(context: import("./type").UploadRemoveContext) => void>;
    onSelectChange: import("vue").PropType<(files: File[], context: import("./type").UploadSelectChangeContext) => void>;
    onSuccess: import("vue").PropType<(context: import("./type").SuccessContext) => void>;
    onValidate: import("vue").PropType<(context: {
        type: import("./type").UploadValidateType;
        files: import("./type").UploadFile[];
    }) => void>;
    onWaitingUploadFilesChange: import("vue").PropType<(context: {
        files: import("./type").UploadFile[];
        trigger: "remove" | "validate" | "uploaded";
    }) => void>;
}>> & Omit<import("vue").VueConstructor<import("vue").default>, never> & (new (...args: any[]) => import("@vue/composition-api").ComponentRenderProxy<{
    max: number;
    name: string;
    value: import("./type").UploadFile[];
    action: string;
    method: "options" | "get" | "post" | "POST" | "GET" | "PUT" | "OPTIONS" | "PATCH" | "put" | "patch";
    draggable: boolean;
    disabled: boolean;
    multiple: boolean;
    theme: "file" | "custom" | "image" | "file-input" | "file-flow" | "image-flow";
    defaultValue: import("./type").UploadFile[];
    placeholder: string;
    files: import("./type").UploadFile[];
    defaultFiles: import("./type").UploadFile[];
    accept: string;
    autoUpload: boolean;
    showUploadProgress: boolean;
    showImageFileName: boolean;
    isBatchUpload: boolean;
    showThumbnail: boolean;
    withCredentials: boolean;
    useMockProgress: boolean;
    uploadAllFilesInOneRequest: boolean;
    allowUploadDuplicateFile: boolean;
    uploadPastedFiles: boolean;
} & {
    data?: unknown;
    default?: string | ((h: import("vue").CreateElement) => import("vue/types/vnode").ScopedSlotReturnValue);
    status?: "error" | "default" | "success" | "warning";
    onChange?: (value: import("./type").UploadFile[], context: import("./type").UploadChangeContext) => void;
    formatResponse?: (response: any, context: import("./type").FormatResponseContext) => import("./type").ResponseType;
    format?: (file: File) => import("./type").UploadFile;
    tips?: string | ((h: import("vue").CreateElement) => import("vue/types/vnode").ScopedSlotReturnValue);
    onValidate?: (context: {
        type: import("./type").UploadValidateType;
        files: import("./type").UploadFile[];
    }) => void;
    trigger?: (h: import("vue").CreateElement, props: import("./type").TriggerContext) => import("vue/types/vnode").ScopedSlotReturnValue;
    onRemove?: (context: import("./type").UploadRemoveContext) => void;
    onDrop?: (context: {
        e: DragEvent;
    }) => void;
    locale?: unknown;
    onSelectChange?: (files: File[], context: import("./type").UploadSelectChangeContext) => void;
    abridgeName?: number[];
    beforeAllFilesUpload?: (file: import("./type").UploadFile[]) => boolean | Promise<boolean>;
    beforeUpload?: (file: import("./type").UploadFile) => boolean | Promise<boolean>;
    cancelUploadButton?: unknown;
    dragContent?: ((h: import("vue").CreateElement) => import("vue/types/vnode").ScopedSlotReturnValue) | ((h: import("vue").CreateElement, props: import("./type").TriggerContext) => import("vue/types/vnode").ScopedSlotReturnValue);
    fileListDisplay?: (h: import("vue").CreateElement, props: {
        files: import("./type").UploadFile[];
        dragEvents?: import("..").UploadDisplayDragEvents;
    }) => import("vue/types/vnode").ScopedSlotReturnValue;
    formatRequest?: (requestData: {
        [key: string]: any;
    }) => {
        [key: string]: any;
    };
    headers?: {
        [key: string]: string;
    };
    imageViewerProps?: unknown;
    inputAttributes?: object;
    requestMethod?: (files: import("./type").UploadFile | import("./type").UploadFile[]) => Promise<import("./type").RequestMethodResponse>;
    sizeLimit?: number | import("./type").SizeLimitObj;
    triggerButtonProps?: unknown;
    uploadButton?: unknown;
    onCancelUpload?: () => void;
    onDragenter?: (context: {
        e: DragEvent;
    }) => void;
    onDragleave?: (context: {
        e: DragEvent;
    }) => void;
    onFail?: (options: import("./type").UploadFailContext) => void;
    onOneFileFail?: (options: import("./type").UploadFailContext) => void;
    onOneFileSuccess?: (context: Pick<import("./type").SuccessContext, "file" | "response" | "e" | "XMLHttpRequest">) => void;
    onPreview?: (options: {
        file: import("./type").UploadFile;
        index: number;
        e: MouseEvent;
    }) => void;
    onProgress?: (options: import("./type").ProgressContext) => void;
    onSuccess?: (context: import("./type").SuccessContext) => void;
    onWaitingUploadFilesChange?: (context: {
        files: import("./type").UploadFile[];
        trigger: "remove" | "validate" | "uploaded";
    }) => void;
    mockProgressDuration?: number;
}, import("@vue/composition-api").ShallowUnwrapRef<{
    handlePasteFileChange: (e: ClipboardEvent) => void;
    commonDisplayFileProps: import("@vue/composition-api").ComputedRef<import("./interface").CommonDisplayFileProps>;
    dragProps: import("@vue/composition-api").ComputedRef<import("./hooks/useDrag").UploadDragEvents>;
    uploadClasses: import("@vue/composition-api").ComputedRef<(string | {
        [x: string]: boolean;
    })[]>;
    sizeOverLimitMessage: import("@vue/composition-api").Ref<string>;
    tDisabled: import("@vue/composition-api").ComputedRef<boolean>;
    icons: import("tdesign-icons-vue").GlobalIconConfig;
    t: <T>(pattern: T, ...args: any[]) => any;
    localeConfig: import("@vue/composition-api").ComputedRef<({} & import("..").UploadConfig) | ({} & {
        readonly sizeLimitMessage: "文件大小不能超过 {sizeLimit}";
        readonly cancelUploadText: "取消上传";
        readonly triggerUploadText: {
            readonly fileInput: "选择文件";
            readonly image: "点击上传图片";
            readonly normal: "点击上传";
            readonly reupload: "重新选择";
            readonly continueUpload: "继续选择";
            readonly delete: "删除";
            readonly uploading: "上传中";
        };
        readonly dragger: {
            readonly dragDropText: "释放鼠标";
            readonly draggingText: "拖拽到此区域";
            readonly clickAndDragText: "点击上方“选择文件”或将文件拖拽到此区域";
        };
        readonly file: {
            readonly fileNameText: "文件名";
            readonly fileSizeText: "文件大小";
            readonly fileStatusText: "状态";
            readonly fileOperationText: "操作";
            readonly fileOperationDateText: "上传日期";
        };
        readonly progress: {
            readonly uploadingText: "上传中";
            readonly waitingText: "待上传";
            readonly failText: "上传失败";
            readonly successText: "上传成功";
        };
    } & import("..").UploadConfig)>;
    classPrefix: import("@vue/composition-api").Ref<string>;
    triggerUploadText: import("@vue/composition-api").ComputedRef<any>;
    toUploadFiles: import("@vue/composition-api").Ref<{
        [x: string]: any;
        lastModified?: number;
        name?: string;
        percent?: number;
        raw?: File;
        response?: {
            [x: string]: any;
        };
        size?: number;
        status?: "progress" | "waiting" | "success" | "fail";
        type?: string;
        uploadTime?: string;
        url?: string;
    }[]>;
    uploadValue: import("@vue/composition-api").Ref<import("./type").UploadFile[]>;
    displayFiles: import("@vue/composition-api").ComputedRef<import("../_common/js/upload/types").UploadFile[]>;
    uploading: import("@vue/composition-api").Ref<boolean>;
    tipsClasses: string;
    errorClasses: string[];
    placeholderClass: string;
    inputRef: import("@vue/composition-api").Ref<HTMLInputElement>;
    innerDisabled: import("@vue/composition-api").ComputedRef<boolean>;
    xhrReq: import("@vue/composition-api").Ref<{
        files: {
            [x: string]: any;
            lastModified?: number;
            name?: string;
            percent?: number;
            raw?: File;
            response?: {
                [x: string]: any;
            };
            size?: number;
            status?: "progress" | "waiting" | "success" | "fail";
            type?: string;
            uploadTime?: string;
            url?: string;
        }[];
        xhrReq: {
            onreadystatechange: (this: XMLHttpRequest, ev: Event) => any;
            readonly readyState: number;
            readonly response: any;
            readonly responseText: string;
            responseType: XMLHttpRequestResponseType;
            readonly responseURL: string;
            readonly responseXML: Document;
            readonly status: number;
            readonly statusText: string;
            timeout: number;
            readonly upload: {
                addEventListener: {
                    <K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestUpload, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
                };
                removeEventListener: {
                    <K_1 extends keyof XMLHttpRequestEventTargetEventMap>(type: K_1, listener: (this: XMLHttpRequestUpload, ev: XMLHttpRequestEventTargetEventMap[K_1]) => any, options?: boolean | EventListenerOptions): void;
                    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
                };
                onabort: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
                onerror: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
                onload: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
                onloadend: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
                onloadstart: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
                onprogress: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
                ontimeout: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
                dispatchEvent: (event: Event) => boolean;
            };
            withCredentials: boolean;
            abort: () => void;
            getAllResponseHeaders: () => string;
            getResponseHeader: (name: string) => string;
            open: {
                (method: string, url: string | URL): void;
                (method: string, url: string | URL, async: boolean, username?: string, password?: string): void;
            };
            overrideMimeType: (mime: string) => void;
            send: (body?: Document | XMLHttpRequestBodyInit) => void;
            setRequestHeader: (name: string, value: string) => void;
            readonly DONE: number;
            readonly HEADERS_RECEIVED: number;
            readonly LOADING: number;
            readonly OPENED: number;
            readonly UNSENT: number;
            addEventListener: {
                <K_2 extends keyof XMLHttpRequestEventMap>(type: K_2, listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K_2]) => any, options?: boolean | AddEventListenerOptions): void;
                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
            };
            removeEventListener: {
                <K_3 extends keyof XMLHttpRequestEventMap>(type: K_3, listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K_3]) => any, options?: boolean | EventListenerOptions): void;
                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
            };
            onabort: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
            onerror: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
            onload: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
            onloadend: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
            onloadstart: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
            onprogress: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
            ontimeout: (this: XMLHttpRequest, ev: ProgressEvent<EventTarget>) => any;
            dispatchEvent: (event: Event) => boolean;
        };
    }[]>;
    uploadFiles: (toFiles?: import("./type").UploadFile[]) => void;
    uploadFilePercent: (params: {
        file: import("./type").UploadFile;
        percent: number;
    }) => void;
    onFileChange: (files: File[]) => void;
    onNormalFileChange: (e: InputEvent) => void;
    onDragFileChange: (files: File[]) => void;
    onInnerRemove: (p: import("./type").UploadRemoveContext) => void;
    triggerUpload: (e?: MouseEvent) => void;
    cancelUpload: (context?: {
        file?: import("./type").UploadFile;
        e?: MouseEvent;
    }) => void;
    onInnerPreview: (p: {
        file: import("./type").UploadFile;
        index: number;
        e: MouseEvent;
    }) => void;
    innerCancelUpload: () => void;
    onPasteFileChange: (e: ClipboardEvent) => void;
}>, import("@vue/composition-api").Data, {}, {
    renderTrigger(): any;
    getNormalFileNode(): JSX.Element;
    getSingleFileDraggerUploadNode(): JSX.Element;
    getImageCardUploadNode(): JSX.Element;
    getFlowListNode(): JSX.Element;
    getCustomFile(): JSX.Element;
}, {}, {}, {}, {
    max: number;
    name: string;
    value: import("./type").UploadFile[];
    action: string;
    method: "options" | "get" | "post" | "POST" | "GET" | "PUT" | "OPTIONS" | "PATCH" | "put" | "patch";
    draggable: boolean;
    disabled: boolean;
    multiple: boolean;
    theme: "file" | "custom" | "image" | "file-input" | "file-flow" | "image-flow";
    defaultValue: import("./type").UploadFile[];
    placeholder: string;
    files: import("./type").UploadFile[];
    defaultFiles: import("./type").UploadFile[];
    accept: string;
    autoUpload: boolean;
    showUploadProgress: boolean;
    showImageFileName: boolean;
    isBatchUpload: boolean;
    showThumbnail: boolean;
    withCredentials: boolean;
    useMockProgress: boolean;
    uploadAllFilesInOneRequest: boolean;
    allowUploadDuplicateFile: boolean;
    uploadPastedFiles: boolean;
} & {
    data?: unknown;
    default?: string | ((h: import("vue").CreateElement) => import("vue/types/vnode").ScopedSlotReturnValue);
    status?: "error" | "default" | "success" | "warning";
    onChange?: (value: import("./type").UploadFile[], context: import("./type").UploadChangeContext) => void;
    formatResponse?: (response: any, context: import("./type").FormatResponseContext) => import("./type").ResponseType;
    format?: (file: File) => import("./type").UploadFile;
    tips?: string | ((h: import("vue").CreateElement) => import("vue/types/vnode").ScopedSlotReturnValue);
    onValidate?: (context: {
        type: import("./type").UploadValidateType;
        files: import("./type").UploadFile[];
    }) => void;
    trigger?: (h: import("vue").CreateElement, props: import("./type").TriggerContext) => import("vue/types/vnode").ScopedSlotReturnValue;
    onRemove?: (context: import("./type").UploadRemoveContext) => void;
    onDrop?: (context: {
        e: DragEvent;
    }) => void;
    locale?: unknown;
    onSelectChange?: (files: File[], context: import("./type").UploadSelectChangeContext) => void;
    abridgeName?: number[];
    beforeAllFilesUpload?: (file: import("./type").UploadFile[]) => boolean | Promise<boolean>;
    beforeUpload?: (file: import("./type").UploadFile) => boolean | Promise<boolean>;
    cancelUploadButton?: unknown;
    dragContent?: ((h: import("vue").CreateElement) => import("vue/types/vnode").ScopedSlotReturnValue) | ((h: import("vue").CreateElement, props: import("./type").TriggerContext) => import("vue/types/vnode").ScopedSlotReturnValue);
    fileListDisplay?: (h: import("vue").CreateElement, props: {
        files: import("./type").UploadFile[];
        dragEvents?: import("..").UploadDisplayDragEvents;
    }) => import("vue/types/vnode").ScopedSlotReturnValue;
    formatRequest?: (requestData: {
        [key: string]: any;
    }) => {
        [key: string]: any;
    };
    headers?: {
        [key: string]: string;
    };
    imageViewerProps?: unknown;
    inputAttributes?: object;
    requestMethod?: (files: import("./type").UploadFile | import("./type").UploadFile[]) => Promise<import("./type").RequestMethodResponse>;
    sizeLimit?: number | import("./type").SizeLimitObj;
    triggerButtonProps?: unknown;
    uploadButton?: unknown;
    onCancelUpload?: () => void;
    onDragenter?: (context: {
        e: DragEvent;
    }) => void;
    onDragleave?: (context: {
        e: DragEvent;
    }) => void;
    onFail?: (options: import("./type").UploadFailContext) => void;
    onOneFileFail?: (options: import("./type").UploadFailContext) => void;
    onOneFileSuccess?: (context: Pick<import("./type").SuccessContext, "file" | "response" | "e" | "XMLHttpRequest">) => void;
    onPreview?: (options: {
        file: import("./type").UploadFile;
        index: number;
        e: MouseEvent;
    }) => void;
    onProgress?: (options: import("./type").ProgressContext) => void;
    onSuccess?: (context: import("./type").SuccessContext) => void;
    onWaitingUploadFilesChange?: (context: {
        files: import("./type").UploadFile[];
        trigger: "remove" | "validate" | "uploaded";
    }) => void;
    mockProgressDuration?: number;
}, {
    max: number;
    name: string;
    value: import("./type").UploadFile[];
    action: string;
    method: "options" | "get" | "post" | "POST" | "GET" | "PUT" | "OPTIONS" | "PATCH" | "put" | "patch";
    draggable: boolean;
    disabled: boolean;
    multiple: boolean;
    theme: "file" | "custom" | "image" | "file-input" | "file-flow" | "image-flow";
    defaultValue: import("./type").UploadFile[];
    placeholder: string;
    files: import("./type").UploadFile[];
    defaultFiles: import("./type").UploadFile[];
    accept: string;
    autoUpload: boolean;
    showUploadProgress: boolean;
    showImageFileName: boolean;
    isBatchUpload: boolean;
    showThumbnail: boolean;
    withCredentials: boolean;
    useMockProgress: boolean;
    uploadAllFilesInOneRequest: boolean;
    allowUploadDuplicateFile: boolean;
    uploadPastedFiles: boolean;
}, true>)>;
export default Upload;
export * from './type';