import UploadPro from './UploadPro.vue';
export declare const GmUploadPro: import("../../../../utils").SFCWithInstall<{
    new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
        listType: {
            type: import("vue").PropType<"text" | "picture" | "picture-card">;
            default: string;
        };
        drag: {
            type: BooleanConstructor;
            default: boolean;
        };
        domainCode: {
            type: StringConstructor;
        };
        sceneCode: {
            type: StringConstructor;
        };
        acl: {
            type: StringConstructor;
            default: string;
        };
        rename: {
            type: NumberConstructor;
            default: number;
        };
        showLoading: {
            type: BooleanConstructor;
            default: boolean;
        };
        showDelete: {
            type: BooleanConstructor;
            default: boolean;
        };
        disabledDeleteUids: {
            type: import("vue").PropType<number[]>;
            default: () => never[];
        };
        deleteTip: {
            type: BooleanConstructor;
            default: boolean;
        };
        checkbox: {
            type: BooleanConstructor;
            default: boolean;
        };
        disabledCheckboxUids: {
            type: import("vue").PropType<number[]>;
            default: () => never[];
        };
        width: {
            type: NumberConstructor;
            default: number;
        };
        height: {
            type: NumberConstructor;
            default: number;
        };
        onAllComplete: {
            type: import("vue").PropType<() => void>;
            default: () => void;
        };
        beforeUpload: {
            readonly type: import("vue").PropType<(rawFile: import("element-plus").UploadRawFile) => boolean | void | Blob | File | Promise<boolean | void | Blob | File | null | undefined> | null | undefined>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => void;
        };
        beforeRemove: {
            readonly type: import("vue").PropType<(uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => boolean | Promise<boolean>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        onRemove: {
            readonly type: import("vue").PropType<(uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => void;
        };
        onChange: {
            readonly type: import("vue").PropType<(uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => void;
        };
        onPreview: {
            readonly type: import("vue").PropType<(uploadFile: import("element-plus").UploadFile) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => void;
        };
        onSuccess: {
            readonly type: import("vue").PropType<(response: any, uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => void;
        };
        onProgress: {
            readonly type: import("vue").PropType<(evt: import("element-plus").UploadProgressEvent, uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => void;
        };
        onError: {
            readonly type: import("vue").PropType<(error: Error, uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => void;
        };
        onExceed: {
            readonly type: import("vue").PropType<(files: File[], uploadFiles: import("element-plus").UploadUserFile[]) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => void;
        };
        crossorigin: {
            readonly type: import("vue").PropType<"" | "anonymous" | "use-credentials">;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        action: {
            readonly type: import("vue").PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "#";
        };
        headers: {
            readonly type: import("vue").PropType<Record<string, any> | Headers>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        method: {
            readonly type: import("vue").PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "post";
        };
        data: {
            readonly type: import("vue").PropType<({
                [x: string]: any;
            } | Promise<{
                [x: string]: any;
            }>) | ((rawFile: import("element-plus").UploadRawFile) => {
                [x: string]: any;
            } | Promise<{
                [x: string]: any;
            }>)>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => {};
        };
        multiple: BooleanConstructor;
        name: {
            readonly type: import("vue").PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "file";
        };
        withCredentials: BooleanConstructor;
        showFileList: {
            readonly type: import("vue").PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        accept: {
            readonly type: import("vue").PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "";
        };
        fileList: {
            readonly type: import("vue").PropType<import("element-plus").UploadUserFile[]>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => [];
        };
        autoUpload: {
            readonly type: import("vue").PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        httpRequest: {
            readonly type: import("vue").PropType<import("element-plus").UploadRequestHandler>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: import("element-plus").UploadRequestHandler;
        };
        disabled: BooleanConstructor;
        limit: NumberConstructor;
        checkoutFiles: {
            type: import("vue").PropType<any[]>;
        };
    }>> & {
        "onUpdate:fileList"?: ((value: import("../../../../hooks/index.js").UploadUserFile[]) => any) | undefined;
        onHandleRemove?: ((file: {
            file: import("../../../../hooks/index.js").UploadFile;
            index: number;
        }) => any) | undefined;
        "onUpdate:checkoutFiles"?: ((value: any[]) => any) | undefined;
    }, {
        uploadFileRef: import("vue").Ref<import("element-plus").UploadInstance | undefined>;
        loadingUids: import("vue").Ref<Set<number> & Omit<Set<number>, keyof Set<any>>>;
        submit: () => void;
        abort: (file: import("element-plus").UploadFile) => void;
        clearFiles: (states?: import("element-plus").UploadStatus[] | undefined) => void;
        handleStart: (rawFile: import("element-plus").UploadRawFile) => void;
        handleRemove: (file: import("element-plus").UploadRawFile | import("element-plus").UploadFile) => void;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        handleRemove: (file: {
            file: import("../../../../hooks/index.js").UploadFile;
            index: number;
        }) => void;
        "update:fileList": (value: import("../../../../hooks/index.js").UploadUserFile[]) => void;
        "update:checkoutFiles": (value: any[]) => void;
    }, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
        listType: {
            type: import("vue").PropType<"text" | "picture" | "picture-card">;
            default: string;
        };
        drag: {
            type: BooleanConstructor;
            default: boolean;
        };
        domainCode: {
            type: StringConstructor;
        };
        sceneCode: {
            type: StringConstructor;
        };
        acl: {
            type: StringConstructor;
            default: string;
        };
        rename: {
            type: NumberConstructor;
            default: number;
        };
        showLoading: {
            type: BooleanConstructor;
            default: boolean;
        };
        showDelete: {
            type: BooleanConstructor;
            default: boolean;
        };
        disabledDeleteUids: {
            type: import("vue").PropType<number[]>;
            default: () => never[];
        };
        deleteTip: {
            type: BooleanConstructor;
            default: boolean;
        };
        checkbox: {
            type: BooleanConstructor;
            default: boolean;
        };
        disabledCheckboxUids: {
            type: import("vue").PropType<number[]>;
            default: () => never[];
        };
        width: {
            type: NumberConstructor;
            default: number;
        };
        height: {
            type: NumberConstructor;
            default: number;
        };
        onAllComplete: {
            type: import("vue").PropType<() => void>;
            default: () => void;
        };
        beforeUpload: {
            readonly type: import("vue").PropType<(rawFile: import("element-plus").UploadRawFile) => boolean | void | Blob | File | Promise<boolean | void | Blob | File | null | undefined> | null | undefined>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => void;
        };
        beforeRemove: {
            readonly type: import("vue").PropType<(uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => boolean | Promise<boolean>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        onRemove: {
            readonly type: import("vue").PropType<(uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => void;
        };
        onChange: {
            readonly type: import("vue").PropType<(uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => void;
        };
        onPreview: {
            readonly type: import("vue").PropType<(uploadFile: import("element-plus").UploadFile) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => void;
        };
        onSuccess: {
            readonly type: import("vue").PropType<(response: any, uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => void;
        };
        onProgress: {
            readonly type: import("vue").PropType<(evt: import("element-plus").UploadProgressEvent, uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => void;
        };
        onError: {
            readonly type: import("vue").PropType<(error: Error, uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => void;
        };
        onExceed: {
            readonly type: import("vue").PropType<(files: File[], uploadFiles: import("element-plus").UploadUserFile[]) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => void;
        };
        crossorigin: {
            readonly type: import("vue").PropType<"" | "anonymous" | "use-credentials">;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        action: {
            readonly type: import("vue").PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "#";
        };
        headers: {
            readonly type: import("vue").PropType<Record<string, any> | Headers>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        method: {
            readonly type: import("vue").PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "post";
        };
        data: {
            readonly type: import("vue").PropType<({
                [x: string]: any;
            } | Promise<{
                [x: string]: any;
            }>) | ((rawFile: import("element-plus").UploadRawFile) => {
                [x: string]: any;
            } | Promise<{
                [x: string]: any;
            }>)>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => {};
        };
        multiple: BooleanConstructor;
        name: {
            readonly type: import("vue").PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "file";
        };
        withCredentials: BooleanConstructor;
        showFileList: {
            readonly type: import("vue").PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        accept: {
            readonly type: import("vue").PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "";
        };
        fileList: {
            readonly type: import("vue").PropType<import("element-plus").UploadUserFile[]>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => [];
        };
        autoUpload: {
            readonly type: import("vue").PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        httpRequest: {
            readonly type: import("vue").PropType<import("element-plus").UploadRequestHandler>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: import("element-plus").UploadRequestHandler;
        };
        disabled: BooleanConstructor;
        limit: NumberConstructor;
        checkoutFiles: {
            type: import("vue").PropType<any[]>;
        };
    }>> & {
        "onUpdate:fileList"?: ((value: import("../../../../hooks/index.js").UploadUserFile[]) => any) | undefined;
        onHandleRemove?: ((file: {
            file: import("../../../../hooks/index.js").UploadFile;
            index: number;
        }) => any) | undefined;
        "onUpdate:checkoutFiles"?: ((value: any[]) => any) | undefined;
    }, {
        onError: (error: Error, uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void;
        method: string;
        data: ({
            [x: string]: any;
        } | Promise<{
            [x: string]: any;
        }>) | ((rawFile: import("element-plus").UploadRawFile) => {
            [x: string]: any;
        } | Promise<{
            [x: string]: any;
        }>);
        withCredentials: boolean;
        onSuccess: (response: any, uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void;
        name: string;
        checkbox: boolean;
        height: number;
        width: number;
        drag: boolean;
        multiple: boolean;
        disabled: boolean;
        onChange: (uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void;
        onProgress: (evt: import("element-plus").UploadProgressEvent, uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void;
        accept: string;
        acl: string;
        rename: number;
        beforeUpload: (rawFile: import("element-plus").UploadRawFile) => boolean | void | Blob | File | Promise<boolean | void | Blob | File | null | undefined> | null | undefined;
        onRemove: (uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void;
        onPreview: (uploadFile: import("element-plus").UploadFile) => void;
        onExceed: (files: File[], uploadFiles: import("element-plus").UploadUserFile[]) => void;
        action: string;
        showFileList: boolean;
        fileList: import("element-plus").UploadUserFile[];
        autoUpload: boolean;
        listType: "text" | "picture" | "picture-card";
        httpRequest: import("element-plus").UploadRequestHandler;
        showLoading: boolean;
        showDelete: boolean;
        disabledDeleteUids: number[];
        deleteTip: boolean;
        disabledCheckboxUids: number[];
        onAllComplete: () => void;
    }, true, {}, {}, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<import("vue").ExtractPropTypes<{
        listType: {
            type: import("vue").PropType<"text" | "picture" | "picture-card">;
            default: string;
        };
        drag: {
            type: BooleanConstructor;
            default: boolean;
        };
        domainCode: {
            type: StringConstructor;
        };
        sceneCode: {
            type: StringConstructor;
        };
        acl: {
            type: StringConstructor;
            default: string;
        };
        rename: {
            type: NumberConstructor;
            default: number;
        };
        showLoading: {
            type: BooleanConstructor;
            default: boolean;
        };
        showDelete: {
            type: BooleanConstructor;
            default: boolean;
        };
        disabledDeleteUids: {
            type: import("vue").PropType<number[]>;
            default: () => never[];
        };
        deleteTip: {
            type: BooleanConstructor;
            default: boolean;
        };
        checkbox: {
            type: BooleanConstructor;
            default: boolean;
        };
        disabledCheckboxUids: {
            type: import("vue").PropType<number[]>;
            default: () => never[];
        };
        width: {
            type: NumberConstructor;
            default: number;
        };
        height: {
            type: NumberConstructor;
            default: number;
        };
        onAllComplete: {
            type: import("vue").PropType<() => void>;
            default: () => void;
        };
        beforeUpload: {
            readonly type: import("vue").PropType<(rawFile: import("element-plus").UploadRawFile) => boolean | void | Blob | File | Promise<boolean | void | Blob | File | null | undefined> | null | undefined>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => void;
        };
        beforeRemove: {
            readonly type: import("vue").PropType<(uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => boolean | Promise<boolean>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        onRemove: {
            readonly type: import("vue").PropType<(uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => void;
        };
        onChange: {
            readonly type: import("vue").PropType<(uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => void;
        };
        onPreview: {
            readonly type: import("vue").PropType<(uploadFile: import("element-plus").UploadFile) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => void;
        };
        onSuccess: {
            readonly type: import("vue").PropType<(response: any, uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => void;
        };
        onProgress: {
            readonly type: import("vue").PropType<(evt: import("element-plus").UploadProgressEvent, uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => void;
        };
        onError: {
            readonly type: import("vue").PropType<(error: Error, uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => void;
        };
        onExceed: {
            readonly type: import("vue").PropType<(files: File[], uploadFiles: import("element-plus").UploadUserFile[]) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => void;
        };
        crossorigin: {
            readonly type: import("vue").PropType<"" | "anonymous" | "use-credentials">;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        action: {
            readonly type: import("vue").PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "#";
        };
        headers: {
            readonly type: import("vue").PropType<Record<string, any> | Headers>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        method: {
            readonly type: import("vue").PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "post";
        };
        data: {
            readonly type: import("vue").PropType<({
                [x: string]: any;
            } | Promise<{
                [x: string]: any;
            }>) | ((rawFile: import("element-plus").UploadRawFile) => {
                [x: string]: any;
            } | Promise<{
                [x: string]: any;
            }>)>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => {};
        };
        multiple: BooleanConstructor;
        name: {
            readonly type: import("vue").PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "file";
        };
        withCredentials: BooleanConstructor;
        showFileList: {
            readonly type: import("vue").PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        accept: {
            readonly type: import("vue").PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "";
        };
        fileList: {
            readonly type: import("vue").PropType<import("element-plus").UploadUserFile[]>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => [];
        };
        autoUpload: {
            readonly type: import("vue").PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        httpRequest: {
            readonly type: import("vue").PropType<import("element-plus").UploadRequestHandler>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: import("element-plus").UploadRequestHandler;
        };
        disabled: BooleanConstructor;
        limit: NumberConstructor;
        checkoutFiles: {
            type: import("vue").PropType<any[]>;
        };
    }>> & {
        "onUpdate:fileList"?: ((value: import("../../../../hooks/index.js").UploadUserFile[]) => any) | undefined;
        onHandleRemove?: ((file: {
            file: import("../../../../hooks/index.js").UploadFile;
            index: number;
        }) => any) | undefined;
        "onUpdate:checkoutFiles"?: ((value: any[]) => any) | undefined;
    }, {
        uploadFileRef: import("vue").Ref<import("element-plus").UploadInstance | undefined>;
        loadingUids: import("vue").Ref<Set<number> & Omit<Set<number>, keyof Set<any>>>;
        submit: () => void;
        abort: (file: import("element-plus").UploadFile) => void;
        clearFiles: (states?: import("element-plus").UploadStatus[] | undefined) => void;
        handleStart: (rawFile: import("element-plus").UploadRawFile) => void;
        handleRemove: (file: import("element-plus").UploadRawFile | import("element-plus").UploadFile) => void;
    }, {}, {}, {}, {
        onError: (error: Error, uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void;
        method: string;
        data: ({
            [x: string]: any;
        } | Promise<{
            [x: string]: any;
        }>) | ((rawFile: import("element-plus").UploadRawFile) => {
            [x: string]: any;
        } | Promise<{
            [x: string]: any;
        }>);
        withCredentials: boolean;
        onSuccess: (response: any, uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void;
        name: string;
        checkbox: boolean;
        height: number;
        width: number;
        drag: boolean;
        multiple: boolean;
        disabled: boolean;
        onChange: (uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void;
        onProgress: (evt: import("element-plus").UploadProgressEvent, uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void;
        accept: string;
        acl: string;
        rename: number;
        beforeUpload: (rawFile: import("element-plus").UploadRawFile) => boolean | void | Blob | File | Promise<boolean | void | Blob | File | null | undefined> | null | undefined;
        onRemove: (uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void;
        onPreview: (uploadFile: import("element-plus").UploadFile) => void;
        onExceed: (files: File[], uploadFiles: import("element-plus").UploadUserFile[]) => void;
        action: string;
        showFileList: boolean;
        fileList: import("element-plus").UploadUserFile[];
        autoUpload: boolean;
        listType: "text" | "picture" | "picture-card";
        httpRequest: import("element-plus").UploadRequestHandler;
        showLoading: boolean;
        showDelete: boolean;
        disabledDeleteUids: number[];
        deleteTip: boolean;
        disabledCheckboxUids: number[];
        onAllComplete: () => void;
    }>;
    __isFragment?: undefined;
    __isTeleport?: undefined;
    __isSuspense?: undefined;
} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
    listType: {
        type: import("vue").PropType<"text" | "picture" | "picture-card">;
        default: string;
    };
    drag: {
        type: BooleanConstructor;
        default: boolean;
    };
    domainCode: {
        type: StringConstructor;
    };
    sceneCode: {
        type: StringConstructor;
    };
    acl: {
        type: StringConstructor;
        default: string;
    };
    rename: {
        type: NumberConstructor;
        default: number;
    };
    showLoading: {
        type: BooleanConstructor;
        default: boolean;
    };
    showDelete: {
        type: BooleanConstructor;
        default: boolean;
    };
    disabledDeleteUids: {
        type: import("vue").PropType<number[]>;
        default: () => never[];
    };
    deleteTip: {
        type: BooleanConstructor;
        default: boolean;
    };
    checkbox: {
        type: BooleanConstructor;
        default: boolean;
    };
    disabledCheckboxUids: {
        type: import("vue").PropType<number[]>;
        default: () => never[];
    };
    width: {
        type: NumberConstructor;
        default: number;
    };
    height: {
        type: NumberConstructor;
        default: number;
    };
    onAllComplete: {
        type: import("vue").PropType<() => void>;
        default: () => void;
    };
    beforeUpload: {
        readonly type: import("vue").PropType<(rawFile: import("element-plus").UploadRawFile) => boolean | void | Blob | File | Promise<boolean | void | Blob | File | null | undefined> | null | undefined>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    } & {
        readonly default: () => void;
    };
    beforeRemove: {
        readonly type: import("vue").PropType<(uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => boolean | Promise<boolean>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    onRemove: {
        readonly type: import("vue").PropType<(uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    } & {
        readonly default: () => void;
    };
    onChange: {
        readonly type: import("vue").PropType<(uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    } & {
        readonly default: () => void;
    };
    onPreview: {
        readonly type: import("vue").PropType<(uploadFile: import("element-plus").UploadFile) => void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    } & {
        readonly default: () => void;
    };
    onSuccess: {
        readonly type: import("vue").PropType<(response: any, uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    } & {
        readonly default: () => void;
    };
    onProgress: {
        readonly type: import("vue").PropType<(evt: import("element-plus").UploadProgressEvent, uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    } & {
        readonly default: () => void;
    };
    onError: {
        readonly type: import("vue").PropType<(error: Error, uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    } & {
        readonly default: () => void;
    };
    onExceed: {
        readonly type: import("vue").PropType<(files: File[], uploadFiles: import("element-plus").UploadUserFile[]) => void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    } & {
        readonly default: () => void;
    };
    crossorigin: {
        readonly type: import("vue").PropType<"" | "anonymous" | "use-credentials">;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    action: {
        readonly type: import("vue").PropType<string>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    } & {
        readonly default: "#";
    };
    headers: {
        readonly type: import("vue").PropType<Record<string, any> | Headers>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    method: {
        readonly type: import("vue").PropType<string>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    } & {
        readonly default: "post";
    };
    data: {
        readonly type: import("vue").PropType<({
            [x: string]: any;
        } | Promise<{
            [x: string]: any;
        }>) | ((rawFile: import("element-plus").UploadRawFile) => {
            [x: string]: any;
        } | Promise<{
            [x: string]: any;
        }>)>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    } & {
        readonly default: () => {};
    };
    multiple: BooleanConstructor;
    name: {
        readonly type: import("vue").PropType<string>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    } & {
        readonly default: "file";
    };
    withCredentials: BooleanConstructor;
    showFileList: {
        readonly type: import("vue").PropType<boolean>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    } & {
        readonly default: true;
    };
    accept: {
        readonly type: import("vue").PropType<string>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    } & {
        readonly default: "";
    };
    fileList: {
        readonly type: import("vue").PropType<import("element-plus").UploadUserFile[]>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    } & {
        readonly default: () => [];
    };
    autoUpload: {
        readonly type: import("vue").PropType<boolean>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    } & {
        readonly default: true;
    };
    httpRequest: {
        readonly type: import("vue").PropType<import("element-plus").UploadRequestHandler>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    } & {
        readonly default: import("element-plus").UploadRequestHandler;
    };
    disabled: BooleanConstructor;
    limit: NumberConstructor;
    checkoutFiles: {
        type: import("vue").PropType<any[]>;
    };
}>> & {
    "onUpdate:fileList"?: ((value: import("../../../../hooks/index.js").UploadUserFile[]) => any) | undefined;
    onHandleRemove?: ((file: {
        file: import("../../../../hooks/index.js").UploadFile;
        index: number;
    }) => any) | undefined;
    "onUpdate:checkoutFiles"?: ((value: any[]) => any) | undefined;
}, {
    uploadFileRef: import("vue").Ref<import("element-plus").UploadInstance | undefined>;
    loadingUids: import("vue").Ref<Set<number> & Omit<Set<number>, keyof Set<any>>>;
    submit: () => void;
    abort: (file: import("element-plus").UploadFile) => void;
    clearFiles: (states?: import("element-plus").UploadStatus[] | undefined) => void;
    handleStart: (rawFile: import("element-plus").UploadRawFile) => void;
    handleRemove: (file: import("element-plus").UploadRawFile | import("element-plus").UploadFile) => void;
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
    handleRemove: (file: {
        file: import("../../../../hooks/index.js").UploadFile;
        index: number;
    }) => void;
    "update:fileList": (value: import("../../../../hooks/index.js").UploadUserFile[]) => void;
    "update:checkoutFiles": (value: any[]) => void;
}, string, {
    onError: (error: Error, uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void;
    method: string;
    data: ({
        [x: string]: any;
    } | Promise<{
        [x: string]: any;
    }>) | ((rawFile: import("element-plus").UploadRawFile) => {
        [x: string]: any;
    } | Promise<{
        [x: string]: any;
    }>);
    withCredentials: boolean;
    onSuccess: (response: any, uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void;
    name: string;
    checkbox: boolean;
    height: number;
    width: number;
    drag: boolean;
    multiple: boolean;
    disabled: boolean;
    onChange: (uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void;
    onProgress: (evt: import("element-plus").UploadProgressEvent, uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void;
    accept: string;
    acl: string;
    rename: number;
    beforeUpload: (rawFile: import("element-plus").UploadRawFile) => boolean | void | Blob | File | Promise<boolean | void | Blob | File | null | undefined> | null | undefined;
    onRemove: (uploadFile: import("element-plus").UploadFile, uploadFiles: import("element-plus").UploadFiles) => void;
    onPreview: (uploadFile: import("element-plus").UploadFile) => void;
    onExceed: (files: File[], uploadFiles: import("element-plus").UploadUserFile[]) => void;
    action: string;
    showFileList: boolean;
    fileList: import("element-plus").UploadUserFile[];
    autoUpload: boolean;
    listType: "text" | "picture" | "picture-card";
    httpRequest: import("element-plus").UploadRequestHandler;
    showLoading: boolean;
    showDelete: boolean;
    disabledDeleteUids: number[];
    deleteTip: boolean;
    disabledCheckboxUids: number[];
    onAllComplete: () => void;
}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
    $slots: {
        default?: ((props: {}) => any) | undefined;
    } & {
        file?: ((props: {
            file: import("element-plus").UploadFile;
        }) => any) | undefined;
    } & {
        fileActions?: ((props: {
            file: import("element-plus").UploadFile;
        }) => any) | undefined;
    } & {
        file?: ((props: {
            file: import("element-plus").UploadFile;
            index: number;
        }) => any) | undefined;
    } & {
        trigger?: ((props: {}) => any) | undefined;
    } & {
        tip?: ((props: {}) => any) | undefined;
    };
})> & Record<string, any>;
export type UploadProInstance = InstanceType<typeof UploadPro>;
export * from './uploadPro';
export default GmUploadPro;
