import type { CommonDisplayFileProps } from './interface';
import type { UploadDragEvents } from './hooks/useDrag';
declare const _default: import("vue").ComponentOptions<import("vue").default, import("@vue/composition-api").ShallowUnwrapRef<{
    commonDisplayFileProps: import("@vue/composition-api").ComputedRef<CommonDisplayFileProps>;
    dragProps: import("@vue/composition-api").ComputedRef<UploadDragEvents>;
    uploadClasses: import("@vue/composition-api").ComputedRef<(string | {
        [x: string]: boolean;
    })[]>;
    t: <T>(pattern: T, ...args: any[]) => any;
    localeConfig: import("@vue/composition-api").ComputedRef<{
        cancelUploadText?: string;
        dragger?: {
            clickAndDragText?: string;
            dragDropText?: string;
            draggingText?: string;
        };
        file?: {
            fileNameText?: string;
            fileOperationDateText?: string;
            fileOperationText?: string;
            fileSizeText?: string;
            fileStatusText?: string;
        };
        progress?: {
            failText?: string;
            successText?: string;
            uploadingText?: string;
            waitingText?: string;
        };
        sizeLimitMessage?: string;
        triggerUploadText?: {
            image?: string;
            normal?: string;
            fileInput?: string;
            reupload?: string;
            continueUpload?: string;
            delete?: string;
        };
    } & 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?: {
            readonly lastModified: number;
            readonly name: string;
            readonly webkitRelativePath: string;
            readonly size: number;
            readonly type: string;
            arrayBuffer: () => Promise<ArrayBuffer>;
            slice: (start?: number, end?: number, contentType?: string) => Blob;
            stream: () => ReadableStream<any>;
            text: () => Promise<string>;
        };
        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[]>;
    sizeOverLimitMessage: import("@vue/composition-api").Ref<string>;
    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?: {
                readonly lastModified: number;
                readonly name: string;
                readonly webkitRelativePath: string;
                readonly size: number;
                readonly type: string;
                arrayBuffer: () => Promise<ArrayBuffer>;
                slice: (start?: number, end?: number, contentType?: string) => Blob;
                stream: () => ReadableStream<any>;
                text: () => Promise<string>;
            };
            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;
    onFileChange: (files: FileList) => void;
    onNormalFileChange: (e: InputEvent) => void;
    onDragFileChange: (e: DragEvent) => 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;
}> & 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>>;
    };
    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;
        }>;
    };
    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<"option" | "get" | "post" | "POST" | "GET" | "PUT" | "OPTION" | "PATCH" | "put" | "patch">;
        default: "option" | "get" | "post" | "POST" | "GET" | "PUT" | "OPTION" | "PATCH" | "put" | "patch";
        validator(val: "option" | "get" | "post" | "POST" | "GET" | "PUT" | "OPTION" | "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>>;
    };
    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("../button").TdButtonProps>;
    };
    uploadAllFilesInOneRequest: BooleanConstructor;
    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" | "e" | "response" | "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>>;
    };
    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;
        }>;
    };
    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<"option" | "get" | "post" | "POST" | "GET" | "PUT" | "OPTION" | "PATCH" | "put" | "patch">;
        default: "option" | "get" | "post" | "POST" | "GET" | "PUT" | "OPTION" | "PATCH" | "put" | "patch";
        validator(val: "option" | "get" | "post" | "POST" | "GET" | "PUT" | "OPTION" | "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>>;
    };
    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("../button").TdButtonProps>;
    };
    uploadAllFilesInOneRequest: BooleanConstructor;
    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" | "e" | "response" | "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: "option" | "get" | "post" | "POST" | "GET" | "PUT" | "OPTION" | "PATCH" | "put" | "patch";
    draggable: boolean;
    disabled: boolean;
    multiple: boolean;
    defaultValue: import("./type").UploadFile[];
    placeholder: string;
    theme: "file" | "custom" | "image" | "file-input" | "file-flow" | "image-flow";
    files: import("./type").UploadFile[];
    defaultFiles: import("./type").UploadFile[];
    autoUpload: boolean;
    showUploadProgress: boolean;
    isBatchUpload: boolean;
    withCredentials: boolean;
    useMockProgress: boolean;
    uploadAllFilesInOneRequest: boolean;
    allowUploadDuplicateFile: boolean;
    accept: string;
} & {
    data?: unknown;
    default?: string | ((h: import("vue").CreateElement) => import("vue/types/vnode").ScopedSlotReturnValue);
    status?: "error" | "default" | "success" | "warning";
    trigger?: (h: import("vue").CreateElement, props: import("./type").TriggerContext) => import("vue/types/vnode").ScopedSlotReturnValue;
    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;
    onChange?: (value: import("./type").UploadFile[], context: import("./type").UploadChangeContext) => void;
    onRemove?: (context: import("./type").UploadRemoveContext) => void;
    onDrop?: (context: {
        e: DragEvent;
    }) => void;
    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>;
    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;
    };
    formatResponse?: (response: any, context: import("./type").FormatResponseContext) => import("./type").ResponseType;
    headers?: {
        [key: string]: string;
    };
    inputAttributes?: object;
    locale?: unknown;
    requestMethod?: (files: import("./type").UploadFile | import("./type").UploadFile[]) => Promise<import("./type").RequestMethodResponse>;
    sizeLimit?: number | import("./type").SizeLimitObj;
    triggerButtonProps?: 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" | "e" | "response" | "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<{
    commonDisplayFileProps: import("@vue/composition-api").ComputedRef<CommonDisplayFileProps>;
    dragProps: import("@vue/composition-api").ComputedRef<UploadDragEvents>;
    uploadClasses: import("@vue/composition-api").ComputedRef<(string | {
        [x: string]: boolean;
    })[]>;
    t: <T>(pattern: T, ...args: any[]) => any;
    localeConfig: import("@vue/composition-api").ComputedRef<{
        cancelUploadText?: string;
        dragger?: {
            clickAndDragText?: string;
            dragDropText?: string;
            draggingText?: string;
        };
        file?: {
            fileNameText?: string;
            fileOperationDateText?: string;
            fileOperationText?: string;
            fileSizeText?: string;
            fileStatusText?: string;
        };
        progress?: {
            failText?: string;
            successText?: string;
            uploadingText?: string;
            waitingText?: string;
        };
        sizeLimitMessage?: string;
        triggerUploadText?: {
            image?: string;
            normal?: string;
            fileInput?: string;
            reupload?: string;
            continueUpload?: string;
            delete?: string;
        };
    } & 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?: {
            readonly lastModified: number;
            readonly name: string;
            readonly webkitRelativePath: string;
            readonly size: number;
            readonly type: string;
            arrayBuffer: () => Promise<ArrayBuffer>;
            slice: (start?: number, end?: number, contentType?: string) => Blob;
            stream: () => ReadableStream<any>;
            text: () => Promise<string>;
        };
        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[]>;
    sizeOverLimitMessage: import("@vue/composition-api").Ref<string>;
    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?: {
                readonly lastModified: number;
                readonly name: string;
                readonly webkitRelativePath: string;
                readonly size: number;
                readonly type: string;
                arrayBuffer: () => Promise<ArrayBuffer>;
                slice: (start?: number, end?: number, contentType?: string) => Blob;
                stream: () => ReadableStream<any>;
                text: () => Promise<string>;
            };
            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;
    onFileChange: (files: FileList) => void;
    onNormalFileChange: (e: InputEvent) => void;
    onDragFileChange: (e: DragEvent) => 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;
}>, 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: "option" | "get" | "post" | "POST" | "GET" | "PUT" | "OPTION" | "PATCH" | "put" | "patch";
    draggable: boolean;
    disabled: boolean;
    multiple: boolean;
    defaultValue: import("./type").UploadFile[];
    placeholder: string;
    theme: "file" | "custom" | "image" | "file-input" | "file-flow" | "image-flow";
    files: import("./type").UploadFile[];
    defaultFiles: import("./type").UploadFile[];
    autoUpload: boolean;
    showUploadProgress: boolean;
    isBatchUpload: boolean;
    withCredentials: boolean;
    useMockProgress: boolean;
    uploadAllFilesInOneRequest: boolean;
    allowUploadDuplicateFile: boolean;
    accept: string;
} & {
    data?: unknown;
    default?: string | ((h: import("vue").CreateElement) => import("vue/types/vnode").ScopedSlotReturnValue);
    status?: "error" | "default" | "success" | "warning";
    trigger?: (h: import("vue").CreateElement, props: import("./type").TriggerContext) => import("vue/types/vnode").ScopedSlotReturnValue;
    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;
    onChange?: (value: import("./type").UploadFile[], context: import("./type").UploadChangeContext) => void;
    onRemove?: (context: import("./type").UploadRemoveContext) => void;
    onDrop?: (context: {
        e: DragEvent;
    }) => void;
    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>;
    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;
    };
    formatResponse?: (response: any, context: import("./type").FormatResponseContext) => import("./type").ResponseType;
    headers?: {
        [key: string]: string;
    };
    inputAttributes?: object;
    locale?: unknown;
    requestMethod?: (files: import("./type").UploadFile | import("./type").UploadFile[]) => Promise<import("./type").RequestMethodResponse>;
    sizeLimit?: number | import("./type").SizeLimitObj;
    triggerButtonProps?: 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" | "e" | "response" | "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: "option" | "get" | "post" | "POST" | "GET" | "PUT" | "OPTION" | "PATCH" | "put" | "patch";
    draggable: boolean;
    disabled: boolean;
    multiple: boolean;
    defaultValue: import("./type").UploadFile[];
    placeholder: string;
    theme: "file" | "custom" | "image" | "file-input" | "file-flow" | "image-flow";
    files: import("./type").UploadFile[];
    defaultFiles: import("./type").UploadFile[];
    autoUpload: boolean;
    showUploadProgress: boolean;
    isBatchUpload: boolean;
    withCredentials: boolean;
    useMockProgress: boolean;
    uploadAllFilesInOneRequest: boolean;
    allowUploadDuplicateFile: boolean;
    accept: string;
}, true>);
export default _default;
