3h1-ui 3.0.0-next.249 → 3.0.0-next.250

package/es/ui/src/Upload/src/BasicUpload.vue.d.ts

@@ -0,0 +1,2949 @@
+declare const _sfc_main: import("vue").DefineComponent<{
+    showPreviewNumber: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    emptyHidePreview: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    listType: {
+        type: import("vue").PropType<"picture" | "text" | "picture-card">;
+        default: string;
+    };
+    helpText: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    maxSize: {
+        type: import("vue").PropType<number>;
+        default: number;
+    };
+    maxNumber: {
+        type: import("vue").PropType<number>;
+        default: number;
+    };
+    accept: {
+        type: import("vue").PropType<string[]>;
+        default: () => any[];
+    };
+    multiple: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    uploadParams: {
+        type: import("vue").PropType<any>;
+        default: () => {};
+    };
+    api: {
+        type: import("vue").PropType<PromiseFn<any, any>>;
+        default: any;
+        required: boolean;
+    };
+    name: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    filename: {
+        type: import("vue").PropType<string>;
+        default: any;
+    };
+    fileListOpenDrag: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    fileListDragOptions: {
+        type: import("vue").PropType<{
+            scroll: boolean | HTMLElement;
+            filter: string | ((this: import("sortablejs"), event: Event | TouchEvent, target: HTMLElement, sortable: import("sortablejs")) => boolean);
+            sort: boolean;
+            onChange: (evt: import("sortablejs").SortableEvent) => void;
+            onSelect: (event: import("sortablejs").SortableEvent) => void;
+            disabled: boolean;
+            direction: ((evt: import("sortablejs").SortableEvent, target: HTMLElement, dragEl: HTMLElement) => import("sortablejs").Direction) | import("sortablejs").Direction;
+            draggable: string;
+            group: string | import("sortablejs").GroupOptions;
+            animation: number;
+            chosenClass: string;
+            dataIdAttr: string;
+            delay: number;
+            delayOnTouchOnly: boolean;
+            dragClass: string;
+            dragoverBubble: boolean;
+            dropBubble: boolean;
+            emptyInsertThreshold: number;
+            easing: string;
+            fallbackClass: string;
+            fallbackOnBody: boolean;
+            fallbackTolerance: number;
+            fallbackOffset: {
+                x: number;
+                y: number;
+            };
+            forceFallback: boolean;
+            ghostClass: string;
+            handle: string;
+            ignore: string;
+            invertSwap: boolean;
+            invertedSwapThreshold: number;
+            preventOnFilter: boolean;
+            removeCloneOnHide: boolean;
+            store: {
+                get: (sortable: import("sortablejs")) => string[];
+                set: (sortable: import("sortablejs")) => void;
+            };
+            swapThreshold: number;
+            touchStartThreshold: number;
+            setData: (dataTransfer: DataTransfer, draggedElement: HTMLElement) => void;
+            onStart: (event: import("sortablejs").SortableEvent) => void;
+            onAdd: (event: import("sortablejs").SortableEvent) => void;
+            onClone: (event: import("sortablejs").SortableEvent) => void;
+            onChoose: (event: import("sortablejs").SortableEvent) => void;
+            onUnchoose: (event: import("sortablejs").SortableEvent) => void;
+            onUpdate: (event: import("sortablejs").SortableEvent) => void;
+            onSort: (event: import("sortablejs").SortableEvent) => void;
+            onRemove: (event: import("sortablejs").SortableEvent) => void;
+            onFilter: (event: import("sortablejs").SortableEvent) => void;
+            onMove: (evt: import("sortablejs").MoveEvent, originalEvent: Event) => boolean | void | 1 | -1;
+            forceAutoScrollFallback: boolean;
+            scrollFn: (this: import("sortablejs"), offsetX: number, offsetY: number, originalEvent: Event, touchEvt: TouchEvent, hoverTargetEl: HTMLElement) => void | "continue";
+            scrollSensitivity: number;
+            scrollSpeed: number;
+            bubbleScroll: boolean;
+            multiDrag: boolean;
+            selectedClass: string;
+            multiDragKey: string;
+            avoidImplicitDeselect: boolean;
+            onDeselect: (event: import("sortablejs").SortableEvent) => void;
+            revertOnSpill: boolean;
+            removeOnSpill: boolean;
+            onSpill: (evt: import("sortablejs").SortableEvent) => void;
+            swap: boolean;
+            swapClass: string;
+            onAfterEnd: <T = any, R = any>(params: T) => R;
+        }>;
+        default: () => {};
+    };
+    value: {
+        type: import("vue").PropType<string[]>;
+        default: () => any[];
+    };
+}, {
+    props: any;
+    emit: (event: "delete" | "change" | "update:value" | "preview-delete", ...args: any[]) => void;
+    attrs: {
+        [x: string]: unknown;
+    };
+    t: (key: any) => any;
+    registerUploadModal: import("../../Modal").RegisterFn;
+    openUploadModal: <T_1 = any>(props?: boolean, data?: T_1, openOnSet?: boolean) => void;
+    registerPreviewModal: import("../../Modal").RegisterFn;
+    openPreviewModal: <T_1 = any>(props?: boolean, data?: T_1, openOnSet?: boolean) => void;
+    fileList: import("vue").Ref<string[]>;
+    showPreview: import("vue").ComputedRef<boolean>;
+    bindValue: import("vue").ComputedRef<Pick<{
+        value: string[];
+        name: string;
+        showPreviewNumber: boolean;
+        emptyHidePreview: boolean;
+        listType: "picture" | "text" | "picture-card";
+        helpText: string;
+        maxSize: number;
+        maxNumber: number;
+        accept: string[];
+        multiple: boolean;
+        uploadParams: any;
+        fileListOpenDrag: boolean;
+        fileListDragOptions: {
+            scroll: boolean | HTMLElement;
+            filter: string | ((this: import("sortablejs"), event: Event | TouchEvent, target: HTMLElement, sortable: import("sortablejs")) => boolean);
+            sort: boolean;
+            onChange: (evt: import("sortablejs").SortableEvent) => void;
+            onSelect: (event: import("sortablejs").SortableEvent) => void;
+            disabled: boolean;
+            direction: ((evt: import("sortablejs").SortableEvent, target: HTMLElement, dragEl: HTMLElement) => import("sortablejs").Direction) | import("sortablejs").Direction;
+            draggable: string;
+            group: string | import("sortablejs").GroupOptions;
+            animation: number;
+            chosenClass: string;
+            dataIdAttr: string;
+            delay: number;
+            delayOnTouchOnly: boolean;
+            dragClass: string;
+            dragoverBubble: boolean;
+            dropBubble: boolean;
+            emptyInsertThreshold: number;
+            easing: string;
+            fallbackClass: string;
+            fallbackOnBody: boolean;
+            fallbackTolerance: number;
+            fallbackOffset: {
+                x: number;
+                y: number;
+            };
+            forceFallback: boolean;
+            ghostClass: string;
+            handle: string;
+            ignore: string;
+            invertSwap: boolean;
+            invertedSwapThreshold: number;
+            preventOnFilter: boolean;
+            removeCloneOnHide: boolean;
+            store: {
+                get: (sortable: import("sortablejs")) => string[];
+                set: (sortable: import("sortablejs")) => void;
+            };
+            swapThreshold: number;
+            touchStartThreshold: number;
+            setData: (dataTransfer: DataTransfer, draggedElement: HTMLElement) => void;
+            onStart: (event: import("sortablejs").SortableEvent) => void;
+            onAdd: (event: import("sortablejs").SortableEvent) => void;
+            onClone: (event: import("sortablejs").SortableEvent) => void;
+            onChoose: (event: import("sortablejs").SortableEvent) => void;
+            onUnchoose: (event: import("sortablejs").SortableEvent) => void;
+            onUpdate: (event: import("sortablejs").SortableEvent) => void;
+            onSort: (event: import("sortablejs").SortableEvent) => void;
+            onRemove: (event: import("sortablejs").SortableEvent) => void;
+            onFilter: (event: import("sortablejs").SortableEvent) => void;
+            onMove: (evt: import("sortablejs").MoveEvent, originalEvent: Event) => boolean | void | 1 | -1;
+            forceAutoScrollFallback: boolean;
+            scrollFn: (this: import("sortablejs"), offsetX: number, offsetY: number, originalEvent: Event, touchEvt: TouchEvent, hoverTargetEl: HTMLElement) => void | "continue";
+            scrollSensitivity: number;
+            scrollSpeed: number;
+            bubbleScroll: boolean;
+            multiDrag: boolean;
+            selectedClass: string;
+            multiDragKey: string;
+            avoidImplicitDeselect: boolean;
+            onDeselect: (event: import("sortablejs").SortableEvent) => void;
+            revertOnSpill: boolean;
+            removeOnSpill: boolean;
+            onSpill: (evt: import("sortablejs").SortableEvent) => void;
+            swap: boolean;
+            swapClass: string;
+            onAfterEnd: <T = any, R = any>(params: T) => R;
+        };
+        api: PromiseFn<any, any>;
+        filename: string;
+        onChange: (...args: any[]) => any;
+        "onUpdate:value": (...args: any[]) => any;
+        onDelete: (...args: any[]) => any;
+        "onPreview-delete": (...args: any[]) => any;
+    }, "value" | "name" | "onUpdate:value" | "api" | "onDelete" | "showPreviewNumber" | "emptyHidePreview" | "listType" | "helpText" | "maxSize" | "maxNumber" | "accept" | "multiple" | "uploadParams" | "filename" | "fileListOpenDrag" | "fileListDragOptions" | "onPreview-delete">>;
+    handleChange: (urls: string[]) => void;
+    handlePreviewChange: (urls: string[]) => void;
+    handleDelete: (record: Recordable<any>) => void;
+    handlePreviewDelete: (url: string) => void;
+    Icon: import("vue").DefineComponent<{
+        icon: {
+            type: StringConstructor;
+        };
+        color: {
+            type: StringConstructor;
+        };
+        size: {
+            type: import("vue").PropType<string | number>;
+            default: number;
+        };
+        spin: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        prefix: {
+            type: StringConstructor;
+            default: string;
+        };
+    }, {
+        elRef: import("vue").Ref<any>;
+        getWrapStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+        isSvgIcon: import("vue").ComputedRef<boolean>;
+        getSvgIcon: import("vue").ComputedRef<string>;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        icon: {
+            type: StringConstructor;
+        };
+        color: {
+            type: StringConstructor;
+        };
+        size: {
+            type: import("vue").PropType<string | number>;
+            default: number;
+        };
+        spin: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        prefix: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>>, {
+        size: string | number;
+        prefix: string;
+        spin: boolean;
+    }, {}>;
+    readonly Tooltip: any;
+    readonly Space: any;
+    readonly Button: any;
+    UploadModal: import("vue").DefineComponent<{
+        previewFileList: {
+            type: import("vue").PropType<string[]>;
+            default: () => any[];
+        };
+        listType: {
+            type: import("vue").PropType<"picture" | "text" | "picture-card">;
+            default: string;
+        };
+        helpText: {
+            type: import("vue").PropType<string>;
+            default: string;
+        };
+        maxSize: {
+            type: import("vue").PropType<number>;
+            default: number;
+        };
+        maxNumber: {
+            type: import("vue").PropType<number>;
+            default: number;
+        };
+        accept: {
+            type: import("vue").PropType<string[]>;
+            default: () => any[];
+        };
+        multiple: {
+            type: import("vue").PropType<boolean>;
+            default: boolean;
+        };
+        uploadParams: {
+            type: import("vue").PropType<any>;
+            default: () => {};
+        };
+        api: {
+            type: import("vue").PropType<PromiseFn<any, any>>;
+            default: any;
+            required: boolean;
+        };
+        name: {
+            type: import("vue").PropType<string>;
+            default: string;
+        };
+        filename: {
+            type: import("vue").PropType<string>;
+            default: any;
+        };
+        fileListOpenDrag: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        fileListDragOptions: {
+            type: import("vue").PropType<{
+                scroll: boolean | HTMLElement;
+                filter: string | ((this: import("sortablejs"), event: Event | TouchEvent, target: HTMLElement, sortable: import("sortablejs")) => boolean);
+                sort: boolean;
+                onChange: (evt: import("sortablejs").SortableEvent) => void;
+                onSelect: (event: import("sortablejs").SortableEvent) => void;
+                disabled: boolean;
+                direction: ((evt: import("sortablejs").SortableEvent, target: HTMLElement, dragEl: HTMLElement) => import("sortablejs").Direction) | import("sortablejs").Direction;
+                draggable: string;
+                group: string | import("sortablejs").GroupOptions;
+                animation: number;
+                chosenClass: string;
+                dataIdAttr: string;
+                delay: number;
+                delayOnTouchOnly: boolean;
+                dragClass: string;
+                dragoverBubble: boolean;
+                dropBubble: boolean;
+                emptyInsertThreshold: number;
+                easing: string;
+                fallbackClass: string;
+                fallbackOnBody: boolean;
+                fallbackTolerance: number;
+                fallbackOffset: {
+                    x: number;
+                    y: number;
+                };
+                forceFallback: boolean;
+                ghostClass: string;
+                handle: string;
+                ignore: string;
+                invertSwap: boolean;
+                invertedSwapThreshold: number;
+                preventOnFilter: boolean;
+                removeCloneOnHide: boolean;
+                store: {
+                    get: (sortable: import("sortablejs")) => string[];
+                    set: (sortable: import("sortablejs")) => void;
+                };
+                swapThreshold: number;
+                touchStartThreshold: number;
+                setData: (dataTransfer: DataTransfer, draggedElement: HTMLElement) => void;
+                onStart: (event: import("sortablejs").SortableEvent) => void;
+                onAdd: (event: import("sortablejs").SortableEvent) => void;
+                onClone: (event: import("sortablejs").SortableEvent) => void;
+                onChoose: (event: import("sortablejs").SortableEvent) => void;
+                onUnchoose: (event: import("sortablejs").SortableEvent) => void;
+                onUpdate: (event: import("sortablejs").SortableEvent) => void;
+                onSort: (event: import("sortablejs").SortableEvent) => void;
+                onRemove: (event: import("sortablejs").SortableEvent) => void;
+                onFilter: (event: import("sortablejs").SortableEvent) => void;
+                onMove: (evt: import("sortablejs").MoveEvent, originalEvent: Event) => boolean | void | 1 | -1;
+                forceAutoScrollFallback: boolean;
+                scrollFn: (this: import("sortablejs"), offsetX: number, offsetY: number, originalEvent: Event, touchEvt: TouchEvent, hoverTargetEl: HTMLElement) => void | "continue";
+                scrollSensitivity: number;
+                scrollSpeed: number;
+                bubbleScroll: boolean;
+                multiDrag: boolean;
+                selectedClass: string;
+                multiDragKey: string;
+                avoidImplicitDeselect: boolean;
+                onDeselect: (event: import("sortablejs").SortableEvent) => void;
+                revertOnSpill: boolean;
+                removeOnSpill: boolean;
+                onSpill: (evt: import("sortablejs").SortableEvent) => void;
+                swap: boolean;
+                swapClass: string;
+                onAfterEnd: <T = any, R = any>(params: T) => R;
+            }>;
+            default: () => {};
+        };
+    }, {
+        props: any;
+        emit: (event: "delete" | "change" | "register", ...args: any[]) => void;
+        columns: import("./types/typing").FileBasicColumn[];
+        actionColumn: import("./types/typing").FileBasicColumn;
+        isUploadingRef: import("vue").Ref<boolean>;
+        fileListRef: import("vue").Ref<{
+            thumbUrl?: string;
+            name: string;
+            size: string | number;
+            type?: string;
+            percent: number;
+            file: {
+                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<Uint8Array>;
+                text: () => Promise<string>;
+            };
+            status?: import("./types/typing").UploadResultStatus;
+            response?: {
+                message: string;
+                code: number;
+                url: string;
+            };
+            uuid: string;
+        }[]>;
+        accept: import("vue").Ref<string[]>;
+        helpText: import("vue").Ref<string>;
+        maxNumber: import("vue").Ref<number>;
+        maxSize: import("vue").Ref<number>;
+        t: (key: any) => any;
+        register: import("../../Modal").RegisterFn;
+        closeModal: () => void;
+        getStringAccept: import("vue").ComputedRef<string>;
+        getHelpText: import("vue").ComputedRef<string>;
+        createMessage: any;
+        getIsSelectFile: import("vue").ComputedRef<boolean>;
+        getOkButtonProps: import("vue").ComputedRef<{
+            disabled: boolean;
+        }>;
+        getUploadBtnText: import("vue").ComputedRef<any>;
+        beforeUpload: (file: File) => boolean;
+        handleRemove: (record: import("./types/typing").FileItem) => void;
+        uploadApiByItem: (item: import("./types/typing").FileItem) => Promise<void | {
+            success: boolean;
+            error: any;
+        }>;
+        handleStartUpload: () => Promise<any>;
+        handleOk: () => any;
+        handleCloseFunc: () => Promise<boolean>;
+        readonly Upload: any;
+        readonly Alert: any;
+        readonly BasicModal: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
+                defaultFullscreen: {
+                    type: BooleanConstructor;
+                };
+                canFullscreen: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                wrapperFooterOffset: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                helpMessage: ((new (...args: any[]) => string | string[]) | (() => string | string[])) | ((new (...args: any[]) => string | string[]) | (() => string | string[]))[];
+                useWrapper: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                loading: {
+                    type: BooleanConstructor;
+                };
+                loadingTip: {
+                    type: StringConstructor;
+                };
+                showCancelBtn: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                showOkBtn: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                wrapperProps: ((new (...args: any[]) => Partial<import("../../Modal").ModalWrapperProps>) | (() => Partial<import("../../Modal").ModalWrapperProps>)) | ((new (...args: any[]) => Partial<import("../../Modal").ModalWrapperProps>) | (() => Partial<import("../../Modal").ModalWrapperProps>))[];
+                afterClose: ((new (...args: any[]) => () => Promise<VueNode>) | (() => () => Promise<VueNode>) | {
+                    (): () => Promise<VueNode>;
+                    new (): any;
+                    readonly prototype: any;
+                }) | ((new (...args: any[]) => () => Promise<VueNode>) | (() => () => Promise<VueNode>) | {
+                    (): () => Promise<VueNode>;
+                    new (): any;
+                    readonly prototype: any;
+                })[];
+                bodyStyle: ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties)) | ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties))[];
+                closable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                closeIcon: ((new (...args: any[]) => VueNode & {}) | (() => VueNode)) | ((new (...args: any[]) => VueNode & {}) | (() => VueNode))[];
+                confirmLoading: {
+                    type: BooleanConstructor;
+                };
+                destroyOnClose: {
+                    type: BooleanConstructor;
+                };
+                footer: ((new (...args: any[]) => VueNode & {}) | (() => VueNode)) | ((new (...args: any[]) => VueNode & {}) | (() => VueNode))[];
+                getContainer: ((new (...args: any[]) => () => any) | (() => () => any) | {
+                    (): () => any;
+                    new (): any;
+                    readonly prototype: any;
+                }) | ((new (...args: any[]) => () => any) | (() => () => any) | {
+                    (): () => any;
+                    new (): any;
+                    readonly prototype: any;
+                })[];
+                mask: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maskClosable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                keyboard: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maskStyle: ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties)) | ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties))[];
+                okType: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                okButtonProps: {
+                    type: ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>)) | ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>))[];
+                };
+                cancelButtonProps: {
+                    type: ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>)) | ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>))[];
+                };
+                title: {
+                    type: StringConstructor;
+                };
+                visible: {
+                    type: BooleanConstructor;
+                };
+                width: ((new (...args: any[]) => string | number) | (() => string | number)) | ((new (...args: any[]) => string | number) | (() => string | number))[];
+                wrapClassName: {
+                    type: StringConstructor;
+                };
+                zIndex: {
+                    type: NumberConstructor;
+                };
+                size: {
+                    type: ((new (...args: any[]) => "small" | "default" | "large") | (() => "small" | "default" | "large")) | ((new (...args: any[]) => "small" | "default" | "large") | (() => "small" | "default" | "large"))[];
+                    default: string;
+                };
+                scrollTop: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                height: {
+                    type: NumberConstructor;
+                };
+                minHeight: {
+                    type: NumberConstructor;
+                };
+                draggable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                centered: {
+                    type: BooleanConstructor;
+                };
+                cancelText: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                okText: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                closeFunc: ((new (...args: any[]) => () => Promise<boolean>) | (() => () => Promise<boolean>) | {
+                    (): () => Promise<boolean>;
+                    new (): any;
+                    readonly prototype: any;
+                }) | ((new (...args: any[]) => () => Promise<boolean>) | (() => () => Promise<boolean>) | {
+                    (): () => Promise<boolean>;
+                    new (): any;
+                    readonly prototype: any;
+                })[];
+            }>> & {
+                onCancel?: (...args: any[]) => any;
+                "onHeight-change"?: (...args: any[]) => any;
+                onOk?: (...args: any[]) => any;
+                "onVisible-change"?: (...args: any[]) => any;
+                onRegister?: (...args: any[]) => any;
+                "onUpdate:visible"?: (...args: any[]) => any;
+            }, {
+                prefixCls: string;
+                handleCancel: (e: Event) => Promise<void>;
+                getBindValue: import("vue").ComputedRef<Recordable<any>>;
+                getProps: import("vue").ComputedRef<Recordable<any>>;
+                handleFullScreen: (e: Event) => void;
+                fullScreenRef: import("vue").Ref<boolean>;
+                getMergeProps: import("vue").ComputedRef<Recordable<any>>;
+                handleOk: (e: Event) => void;
+                visibleRef: import("vue").Ref<boolean>;
+                omitBindValue: Object;
+                omitSlotKeys: import("vue").ComputedRef<string[]>;
+                modalWrapperRef: import("vue").Ref<any>;
+                handleExtHeight: (height: number) => void;
+                handleHeightChange: (height: string) => void;
+                handleTitleDbClick: (e: Event) => void;
+                getWrapperHeight: import("vue").ComputedRef<any>;
+            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("cancel" | "height-change" | "ok" | "visible-change" | "register" | "update:visible")[], import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+                defaultFullscreen: {
+                    type: BooleanConstructor;
+                };
+                canFullscreen: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                wrapperFooterOffset: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                helpMessage: ((new (...args: any[]) => string | string[]) | (() => string | string[])) | ((new (...args: any[]) => string | string[]) | (() => string | string[]))[];
+                useWrapper: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                loading: {
+                    type: BooleanConstructor;
+                };
+                loadingTip: {
+                    type: StringConstructor;
+                };
+                showCancelBtn: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                showOkBtn: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                wrapperProps: ((new (...args: any[]) => Partial<import("../../Modal").ModalWrapperProps>) | (() => Partial<import("../../Modal").ModalWrapperProps>)) | ((new (...args: any[]) => Partial<import("../../Modal").ModalWrapperProps>) | (() => Partial<import("../../Modal").ModalWrapperProps>))[];
+                afterClose: ((new (...args: any[]) => () => Promise<VueNode>) | (() => () => Promise<VueNode>) | {
+                    (): () => Promise<VueNode>;
+                    new (): any;
+                    readonly prototype: any;
+                }) | ((new (...args: any[]) => () => Promise<VueNode>) | (() => () => Promise<VueNode>) | {
+                    (): () => Promise<VueNode>;
+                    new (): any;
+                    readonly prototype: any;
+                })[];
+                bodyStyle: ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties)) | ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties))[];
+                closable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                closeIcon: ((new (...args: any[]) => VueNode & {}) | (() => VueNode)) | ((new (...args: any[]) => VueNode & {}) | (() => VueNode))[];
+                confirmLoading: {
+                    type: BooleanConstructor;
+                };
+                destroyOnClose: {
+                    type: BooleanConstructor;
+                };
+                footer: ((new (...args: any[]) => VueNode & {}) | (() => VueNode)) | ((new (...args: any[]) => VueNode & {}) | (() => VueNode))[];
+                getContainer: ((new (...args: any[]) => () => any) | (() => () => any) | {
+                    (): () => any;
+                    new (): any;
+                    readonly prototype: any;
+                }) | ((new (...args: any[]) => () => any) | (() => () => any) | {
+                    (): () => any;
+                    new (): any;
+                    readonly prototype: any;
+                })[];
+                mask: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maskClosable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                keyboard: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maskStyle: ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties)) | ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties))[];
+                okType: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                okButtonProps: {
+                    type: ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>)) | ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>))[];
+                };
+                cancelButtonProps: {
+                    type: ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>)) | ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>))[];
+                };
+                title: {
+                    type: StringConstructor;
+                };
+                visible: {
+                    type: BooleanConstructor;
+                };
+                width: ((new (...args: any[]) => string | number) | (() => string | number)) | ((new (...args: any[]) => string | number) | (() => string | number))[];
+                wrapClassName: {
+                    type: StringConstructor;
+                };
+                zIndex: {
+                    type: NumberConstructor;
+                };
+                size: {
+                    type: ((new (...args: any[]) => "small" | "default" | "large") | (() => "small" | "default" | "large")) | ((new (...args: any[]) => "small" | "default" | "large") | (() => "small" | "default" | "large"))[];
+                    default: string;
+                };
+                scrollTop: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                height: {
+                    type: NumberConstructor;
+                };
+                minHeight: {
+                    type: NumberConstructor;
+                };
+                draggable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                centered: {
+                    type: BooleanConstructor;
+                };
+                cancelText: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                okText: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                closeFunc: ((new (...args: any[]) => () => Promise<boolean>) | (() => () => Promise<boolean>) | {
+                    (): () => Promise<boolean>;
+                    new (): any;
+                    readonly prototype: any;
+                }) | ((new (...args: any[]) => () => Promise<boolean>) | (() => () => Promise<boolean>) | {
+                    (): () => Promise<boolean>;
+                    new (): any;
+                    readonly prototype: any;
+                })[];
+            }>> & {
+                onCancel?: (...args: any[]) => any;
+                "onHeight-change"?: (...args: any[]) => any;
+                onOk?: (...args: any[]) => any;
+                "onVisible-change"?: (...args: any[]) => any;
+                onRegister?: (...args: any[]) => any;
+                "onUpdate:visible"?: (...args: any[]) => any;
+            }, {
+                size: "small" | "default" | "large";
+                mask: boolean;
+                loading: boolean;
+                defaultFullscreen: boolean;
+                canFullscreen: boolean;
+                wrapperFooterOffset: number;
+                useWrapper: boolean;
+                showCancelBtn: boolean;
+                showOkBtn: boolean;
+                visible: boolean;
+                closable: boolean;
+                confirmLoading: boolean;
+                destroyOnClose: boolean;
+                maskClosable: boolean;
+                keyboard: boolean;
+                okType: string;
+                scrollTop: boolean;
+                draggable: boolean;
+                centered: boolean;
+                cancelText: string;
+                okText: string;
+            }, true, {}, {}, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("vue").ExtractPropTypes<{
+                defaultFullscreen: {
+                    type: BooleanConstructor;
+                };
+                canFullscreen: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                wrapperFooterOffset: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                helpMessage: ((new (...args: any[]) => string | string[]) | (() => string | string[])) | ((new (...args: any[]) => string | string[]) | (() => string | string[]))[];
+                useWrapper: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                loading: {
+                    type: BooleanConstructor;
+                };
+                loadingTip: {
+                    type: StringConstructor;
+                };
+                showCancelBtn: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                showOkBtn: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                wrapperProps: ((new (...args: any[]) => Partial<import("../../Modal").ModalWrapperProps>) | (() => Partial<import("../../Modal").ModalWrapperProps>)) | ((new (...args: any[]) => Partial<import("../../Modal").ModalWrapperProps>) | (() => Partial<import("../../Modal").ModalWrapperProps>))[];
+                afterClose: ((new (...args: any[]) => () => Promise<VueNode>) | (() => () => Promise<VueNode>) | {
+                    (): () => Promise<VueNode>;
+                    new (): any;
+                    readonly prototype: any;
+                }) | ((new (...args: any[]) => () => Promise<VueNode>) | (() => () => Promise<VueNode>) | {
+                    (): () => Promise<VueNode>;
+                    new (): any;
+                    readonly prototype: any;
+                })[];
+                bodyStyle: ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties)) | ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties))[];
+                closable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                closeIcon: ((new (...args: any[]) => VueNode & {}) | (() => VueNode)) | ((new (...args: any[]) => VueNode & {}) | (() => VueNode))[];
+                confirmLoading: {
+                    type: BooleanConstructor;
+                };
+                destroyOnClose: {
+                    type: BooleanConstructor;
+                };
+                footer: ((new (...args: any[]) => VueNode & {}) | (() => VueNode)) | ((new (...args: any[]) => VueNode & {}) | (() => VueNode))[];
+                getContainer: ((new (...args: any[]) => () => any) | (() => () => any) | {
+                    (): () => any;
+                    new (): any;
+                    readonly prototype: any;
+                }) | ((new (...args: any[]) => () => any) | (() => () => any) | {
+                    (): () => any;
+                    new (): any;
+                    readonly prototype: any;
+                })[];
+                mask: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maskClosable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                keyboard: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maskStyle: ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties)) | ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties))[];
+                okType: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                okButtonProps: {
+                    type: ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>)) | ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>))[];
+                };
+                cancelButtonProps: {
+                    type: ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>)) | ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>))[];
+                };
+                title: {
+                    type: StringConstructor;
+                };
+                visible: {
+                    type: BooleanConstructor;
+                };
+                width: ((new (...args: any[]) => string | number) | (() => string | number)) | ((new (...args: any[]) => string | number) | (() => string | number))[];
+                wrapClassName: {
+                    type: StringConstructor;
+                };
+                zIndex: {
+                    type: NumberConstructor;
+                };
+                size: {
+                    type: ((new (...args: any[]) => "small" | "default" | "large") | (() => "small" | "default" | "large")) | ((new (...args: any[]) => "small" | "default" | "large") | (() => "small" | "default" | "large"))[];
+                    default: string;
+                };
+                scrollTop: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                height: {
+                    type: NumberConstructor;
+                };
+                minHeight: {
+                    type: NumberConstructor;
+                };
+                draggable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                centered: {
+                    type: BooleanConstructor;
+                };
+                cancelText: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                okText: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                closeFunc: ((new (...args: any[]) => () => Promise<boolean>) | (() => () => Promise<boolean>) | {
+                    (): () => Promise<boolean>;
+                    new (): any;
+                    readonly prototype: any;
+                }) | ((new (...args: any[]) => () => Promise<boolean>) | (() => () => Promise<boolean>) | {
+                    (): () => Promise<boolean>;
+                    new (): any;
+                    readonly prototype: any;
+                })[];
+            }>> & {
+                onCancel?: (...args: any[]) => any;
+                "onHeight-change"?: (...args: any[]) => any;
+                onOk?: (...args: any[]) => any;
+                "onVisible-change"?: (...args: any[]) => any;
+                onRegister?: (...args: any[]) => any;
+                "onUpdate:visible"?: (...args: any[]) => any;
+            }, {
+                prefixCls: string;
+                handleCancel: (e: Event) => Promise<void>;
+                getBindValue: import("vue").ComputedRef<Recordable<any>>;
+                getProps: import("vue").ComputedRef<Recordable<any>>;
+                handleFullScreen: (e: Event) => void;
+                fullScreenRef: import("vue").Ref<boolean>;
+                getMergeProps: import("vue").ComputedRef<Recordable<any>>;
+                handleOk: (e: Event) => void;
+                visibleRef: import("vue").Ref<boolean>;
+                omitBindValue: Object;
+                omitSlotKeys: import("vue").ComputedRef<string[]>;
+                modalWrapperRef: import("vue").Ref<any>;
+                handleExtHeight: (height: number) => void;
+                handleHeightChange: (height: string) => void;
+                handleTitleDbClick: (e: Event) => void;
+                getWrapperHeight: import("vue").ComputedRef<any>;
+            }, {}, {}, {}, {
+                size: "small" | "default" | "large";
+                mask: boolean;
+                loading: boolean;
+                defaultFullscreen: boolean;
+                canFullscreen: boolean;
+                wrapperFooterOffset: number;
+                useWrapper: boolean;
+                showCancelBtn: boolean;
+                showOkBtn: boolean;
+                visible: boolean;
+                closable: boolean;
+                confirmLoading: boolean;
+                destroyOnClose: boolean;
+                maskClosable: boolean;
+                keyboard: boolean;
+                okType: string;
+                scrollTop: boolean;
+                draggable: boolean;
+                centered: boolean;
+                cancelText: string;
+                okText: string;
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            defaultFullscreen: {
+                type: BooleanConstructor;
+            };
+            canFullscreen: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            wrapperFooterOffset: {
+                type: NumberConstructor;
+                default: number;
+            };
+            helpMessage: ((new (...args: any[]) => string | string[]) | (() => string | string[])) | ((new (...args: any[]) => string | string[]) | (() => string | string[]))[];
+            useWrapper: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            loading: {
+                type: BooleanConstructor;
+            };
+            loadingTip: {
+                type: StringConstructor;
+            };
+            showCancelBtn: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            showOkBtn: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            wrapperProps: ((new (...args: any[]) => Partial<import("../../Modal").ModalWrapperProps>) | (() => Partial<import("../../Modal").ModalWrapperProps>)) | ((new (...args: any[]) => Partial<import("../../Modal").ModalWrapperProps>) | (() => Partial<import("../../Modal").ModalWrapperProps>))[];
+            afterClose: ((new (...args: any[]) => () => Promise<VueNode>) | (() => () => Promise<VueNode>) | {
+                (): () => Promise<VueNode>;
+                new (): any;
+                readonly prototype: any;
+            }) | ((new (...args: any[]) => () => Promise<VueNode>) | (() => () => Promise<VueNode>) | {
+                (): () => Promise<VueNode>;
+                new (): any;
+                readonly prototype: any;
+            })[];
+            bodyStyle: ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties)) | ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties))[];
+            closable: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            closeIcon: ((new (...args: any[]) => VueNode & {}) | (() => VueNode)) | ((new (...args: any[]) => VueNode & {}) | (() => VueNode))[];
+            confirmLoading: {
+                type: BooleanConstructor;
+            };
+            destroyOnClose: {
+                type: BooleanConstructor;
+            };
+            footer: ((new (...args: any[]) => VueNode & {}) | (() => VueNode)) | ((new (...args: any[]) => VueNode & {}) | (() => VueNode))[];
+            getContainer: ((new (...args: any[]) => () => any) | (() => () => any) | {
+                (): () => any;
+                new (): any;
+                readonly prototype: any;
+            }) | ((new (...args: any[]) => () => any) | (() => () => any) | {
+                (): () => any;
+                new (): any;
+                readonly prototype: any;
+            })[];
+            mask: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            maskClosable: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            keyboard: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            maskStyle: ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties)) | ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties))[];
+            okType: {
+                type: StringConstructor;
+                default: string;
+            };
+            okButtonProps: {
+                type: ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>)) | ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>))[];
+            };
+            cancelButtonProps: {
+                type: ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>)) | ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>))[];
+            };
+            title: {
+                type: StringConstructor;
+            };
+            visible: {
+                type: BooleanConstructor;
+            };
+            width: ((new (...args: any[]) => string | number) | (() => string | number)) | ((new (...args: any[]) => string | number) | (() => string | number))[];
+            wrapClassName: {
+                type: StringConstructor;
+            };
+            zIndex: {
+                type: NumberConstructor;
+            };
+            size: {
+                type: ((new (...args: any[]) => "small" | "default" | "large") | (() => "small" | "default" | "large")) | ((new (...args: any[]) => "small" | "default" | "large") | (() => "small" | "default" | "large"))[];
+                default: string;
+            };
+            scrollTop: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            height: {
+                type: NumberConstructor;
+            };
+            minHeight: {
+                type: NumberConstructor;
+            };
+            draggable: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            centered: {
+                type: BooleanConstructor;
+            };
+            cancelText: {
+                type: StringConstructor;
+                default: string;
+            };
+            okText: {
+                type: StringConstructor;
+                default: string;
+            };
+            closeFunc: ((new (...args: any[]) => () => Promise<boolean>) | (() => () => Promise<boolean>) | {
+                (): () => Promise<boolean>;
+                new (): any;
+                readonly prototype: any;
+            }) | ((new (...args: any[]) => () => Promise<boolean>) | (() => () => Promise<boolean>) | {
+                (): () => Promise<boolean>;
+                new (): any;
+                readonly prototype: any;
+            })[];
+        }>> & {
+            onCancel?: (...args: any[]) => any;
+            "onHeight-change"?: (...args: any[]) => any;
+            onOk?: (...args: any[]) => any;
+            "onVisible-change"?: (...args: any[]) => any;
+            onRegister?: (...args: any[]) => any;
+            "onUpdate:visible"?: (...args: any[]) => any;
+        }, {
+            prefixCls: string;
+            handleCancel: (e: Event) => Promise<void>;
+            getBindValue: import("vue").ComputedRef<Recordable<any>>;
+            getProps: import("vue").ComputedRef<Recordable<any>>;
+            handleFullScreen: (e: Event) => void;
+            fullScreenRef: import("vue").Ref<boolean>;
+            getMergeProps: import("vue").ComputedRef<Recordable<any>>;
+            handleOk: (e: Event) => void;
+            visibleRef: import("vue").Ref<boolean>;
+            omitBindValue: Object;
+            omitSlotKeys: import("vue").ComputedRef<string[]>;
+            modalWrapperRef: import("vue").Ref<any>;
+            handleExtHeight: (height: number) => void;
+            handleHeightChange: (height: string) => void;
+            handleTitleDbClick: (e: Event) => void;
+            getWrapperHeight: import("vue").ComputedRef<any>;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("cancel" | "height-change" | "ok" | "visible-change" | "register" | "update:visible")[], "cancel" | "height-change" | "ok" | "visible-change" | "register" | "update:visible", {
+            size: "small" | "default" | "large";
+            mask: boolean;
+            loading: boolean;
+            defaultFullscreen: boolean;
+            canFullscreen: boolean;
+            wrapperFooterOffset: number;
+            useWrapper: boolean;
+            showCancelBtn: boolean;
+            showOkBtn: boolean;
+            visible: boolean;
+            closable: boolean;
+            confirmLoading: boolean;
+            destroyOnClose: boolean;
+            maskClosable: boolean;
+            keyboard: boolean;
+            okType: string;
+            scrollTop: boolean;
+            draggable: boolean;
+            centered: boolean;
+            cancelText: string;
+            okText: string;
+        }, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin<any[]>;
+        readonly FileList: import("vue").DefineComponent<{
+            columns: {
+                type: import("vue").PropType<import("./types/typing").FileBasicColumn[]>;
+                default: any;
+            };
+            actionColumn: {
+                type: import("vue").PropType<import("./types/typing").FileBasicColumn>;
+                default: any;
+            };
+            dataSource: {
+                type: import("vue").PropType<any[]>;
+                default: any;
+            };
+            openDrag: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            dragOptions: {
+                type: import("vue").PropType<{
+                    scroll: boolean | HTMLElement;
+                    filter: string | ((this: import("sortablejs"), event: Event | TouchEvent, target: HTMLElement, sortable: import("sortablejs")) => boolean);
+                    sort: boolean;
+                    onChange: (evt: import("sortablejs").SortableEvent) => void;
+                    onSelect: (event: import("sortablejs").SortableEvent) => void;
+                    disabled: boolean;
+                    direction: ((evt: import("sortablejs").SortableEvent, target: HTMLElement, dragEl: HTMLElement) => import("sortablejs").Direction) | import("sortablejs").Direction;
+                    draggable: string;
+                    group: string | import("sortablejs").GroupOptions;
+                    animation: number;
+                    chosenClass: string;
+                    dataIdAttr: string;
+                    delay: number;
+                    delayOnTouchOnly: boolean;
+                    dragClass: string;
+                    dragoverBubble: boolean;
+                    dropBubble: boolean;
+                    emptyInsertThreshold: number;
+                    easing: string;
+                    fallbackClass: string;
+                    fallbackOnBody: boolean;
+                    fallbackTolerance: number;
+                    fallbackOffset: {
+                        x: number;
+                        y: number;
+                    };
+                    forceFallback: boolean;
+                    ghostClass: string;
+                    handle: string;
+                    ignore: string;
+                    invertSwap: boolean;
+                    invertedSwapThreshold: number;
+                    preventOnFilter: boolean;
+                    removeCloneOnHide: boolean;
+                    store: {
+                        get: (sortable: import("sortablejs")) => string[];
+                        set: (sortable: import("sortablejs")) => void;
+                    };
+                    swapThreshold: number;
+                    touchStartThreshold: number;
+                    setData: (dataTransfer: DataTransfer, draggedElement: HTMLElement) => void;
+                    onStart: (event: import("sortablejs").SortableEvent) => void;
+                    onAdd: (event: import("sortablejs").SortableEvent) => void;
+                    onClone: (event: import("sortablejs").SortableEvent) => void;
+                    onChoose: (event: import("sortablejs").SortableEvent) => void;
+                    onUnchoose: (event: import("sortablejs").SortableEvent) => void;
+                    onUpdate: (event: import("sortablejs").SortableEvent) => void;
+                    onSort: (event: import("sortablejs").SortableEvent) => void;
+                    onRemove: (event: import("sortablejs").SortableEvent) => void;
+                    onFilter: (event: import("sortablejs").SortableEvent) => void;
+                    onMove: (evt: import("sortablejs").MoveEvent, originalEvent: Event) => boolean | void | 1 | -1;
+                    forceAutoScrollFallback: boolean;
+                    scrollFn: (this: import("sortablejs"), offsetX: number, offsetY: number, originalEvent: Event, touchEvt: TouchEvent, hoverTargetEl: HTMLElement) => void | "continue";
+                    scrollSensitivity: number;
+                    scrollSpeed: number;
+                    bubbleScroll: boolean;
+                    multiDrag: boolean;
+                    selectedClass: string;
+                    multiDragKey: string;
+                    avoidImplicitDeselect: boolean;
+                    onDeselect: (event: import("sortablejs").SortableEvent) => void;
+                    revertOnSpill: boolean;
+                    removeOnSpill: boolean;
+                    onSpill: (evt: import("sortablejs").SortableEvent) => void;
+                    swap: boolean;
+                    swapClass: string;
+                    onAfterEnd: <T = any, R = any>(params: T) => R;
+                }>;
+                default: () => {};
+            };
+        }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            columns: {
+                type: import("vue").PropType<import("./types/typing").FileBasicColumn[]>;
+                default: any;
+            };
+            actionColumn: {
+                type: import("vue").PropType<import("./types/typing").FileBasicColumn>;
+                default: any;
+            };
+            dataSource: {
+                type: import("vue").PropType<any[]>;
+                default: any;
+            };
+            openDrag: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            dragOptions: {
+                type: import("vue").PropType<{
+                    scroll: boolean | HTMLElement;
+                    filter: string | ((this: import("sortablejs"), event: Event | TouchEvent, target: HTMLElement, sortable: import("sortablejs")) => boolean);
+                    sort: boolean;
+                    onChange: (evt: import("sortablejs").SortableEvent) => void;
+                    onSelect: (event: import("sortablejs").SortableEvent) => void;
+                    disabled: boolean;
+                    direction: ((evt: import("sortablejs").SortableEvent, target: HTMLElement, dragEl: HTMLElement) => import("sortablejs").Direction) | import("sortablejs").Direction;
+                    draggable: string;
+                    group: string | import("sortablejs").GroupOptions;
+                    animation: number;
+                    chosenClass: string;
+                    dataIdAttr: string;
+                    delay: number;
+                    delayOnTouchOnly: boolean;
+                    dragClass: string;
+                    dragoverBubble: boolean;
+                    dropBubble: boolean;
+                    emptyInsertThreshold: number;
+                    easing: string;
+                    fallbackClass: string;
+                    fallbackOnBody: boolean;
+                    fallbackTolerance: number;
+                    fallbackOffset: {
+                        x: number;
+                        y: number;
+                    };
+                    forceFallback: boolean;
+                    ghostClass: string;
+                    handle: string;
+                    ignore: string;
+                    invertSwap: boolean;
+                    invertedSwapThreshold: number;
+                    preventOnFilter: boolean;
+                    removeCloneOnHide: boolean;
+                    store: {
+                        get: (sortable: import("sortablejs")) => string[];
+                        set: (sortable: import("sortablejs")) => void;
+                    };
+                    swapThreshold: number;
+                    touchStartThreshold: number;
+                    setData: (dataTransfer: DataTransfer, draggedElement: HTMLElement) => void;
+                    onStart: (event: import("sortablejs").SortableEvent) => void;
+                    onAdd: (event: import("sortablejs").SortableEvent) => void;
+                    onClone: (event: import("sortablejs").SortableEvent) => void;
+                    onChoose: (event: import("sortablejs").SortableEvent) => void;
+                    onUnchoose: (event: import("sortablejs").SortableEvent) => void;
+                    onUpdate: (event: import("sortablejs").SortableEvent) => void;
+                    onSort: (event: import("sortablejs").SortableEvent) => void;
+                    onRemove: (event: import("sortablejs").SortableEvent) => void;
+                    onFilter: (event: import("sortablejs").SortableEvent) => void;
+                    onMove: (evt: import("sortablejs").MoveEvent, originalEvent: Event) => boolean | void | 1 | -1;
+                    forceAutoScrollFallback: boolean;
+                    scrollFn: (this: import("sortablejs"), offsetX: number, offsetY: number, originalEvent: Event, touchEvt: TouchEvent, hoverTargetEl: HTMLElement) => void | "continue";
+                    scrollSensitivity: number;
+                    scrollSpeed: number;
+                    bubbleScroll: boolean;
+                    multiDrag: boolean;
+                    selectedClass: string;
+                    multiDragKey: string;
+                    avoidImplicitDeselect: boolean;
+                    onDeselect: (event: import("sortablejs").SortableEvent) => void;
+                    revertOnSpill: boolean;
+                    removeOnSpill: boolean;
+                    onSpill: (evt: import("sortablejs").SortableEvent) => void;
+                    swap: boolean;
+                    swapClass: string;
+                    onAfterEnd: <T = any, R = any>(params: T) => R;
+                }>;
+                default: () => {};
+            };
+        }>>, {
+            columns: import("./types/typing").FileBasicColumn[];
+            dataSource: any[];
+            actionColumn: import("./types/typing").FileBasicColumn;
+            openDrag: boolean;
+            dragOptions: {
+                scroll: boolean | HTMLElement;
+                filter: string | ((this: import("sortablejs"), event: Event | TouchEvent, target: HTMLElement, sortable: import("sortablejs")) => boolean);
+                sort: boolean;
+                onChange: (evt: import("sortablejs").SortableEvent) => void;
+                onSelect: (event: import("sortablejs").SortableEvent) => void;
+                disabled: boolean;
+                direction: ((evt: import("sortablejs").SortableEvent, target: HTMLElement, dragEl: HTMLElement) => import("sortablejs").Direction) | import("sortablejs").Direction;
+                draggable: string;
+                group: string | import("sortablejs").GroupOptions;
+                animation: number;
+                chosenClass: string;
+                dataIdAttr: string;
+                delay: number;
+                delayOnTouchOnly: boolean;
+                dragClass: string;
+                dragoverBubble: boolean;
+                dropBubble: boolean;
+                emptyInsertThreshold: number;
+                easing: string;
+                fallbackClass: string;
+                fallbackOnBody: boolean;
+                fallbackTolerance: number;
+                fallbackOffset: {
+                    x: number;
+                    y: number;
+                };
+                forceFallback: boolean;
+                ghostClass: string;
+                handle: string;
+                ignore: string;
+                invertSwap: boolean;
+                invertedSwapThreshold: number;
+                preventOnFilter: boolean;
+                removeCloneOnHide: boolean;
+                store: {
+                    get: (sortable: import("sortablejs")) => string[];
+                    set: (sortable: import("sortablejs")) => void;
+                };
+                swapThreshold: number;
+                touchStartThreshold: number;
+                setData: (dataTransfer: DataTransfer, draggedElement: HTMLElement) => void;
+                onStart: (event: import("sortablejs").SortableEvent) => void;
+                onAdd: (event: import("sortablejs").SortableEvent) => void;
+                onClone: (event: import("sortablejs").SortableEvent) => void;
+                onChoose: (event: import("sortablejs").SortableEvent) => void;
+                onUnchoose: (event: import("sortablejs").SortableEvent) => void;
+                onUpdate: (event: import("sortablejs").SortableEvent) => void;
+                onSort: (event: import("sortablejs").SortableEvent) => void;
+                onRemove: (event: import("sortablejs").SortableEvent) => void;
+                onFilter: (event: import("sortablejs").SortableEvent) => void;
+                onMove: (evt: import("sortablejs").MoveEvent, originalEvent: Event) => boolean | void | 1 | -1;
+                forceAutoScrollFallback: boolean;
+                scrollFn: (this: import("sortablejs"), offsetX: number, offsetY: number, originalEvent: Event, touchEvt: TouchEvent, hoverTargetEl: HTMLElement) => void | "continue";
+                scrollSensitivity: number;
+                scrollSpeed: number;
+                bubbleScroll: boolean;
+                multiDrag: boolean;
+                selectedClass: string;
+                multiDragKey: string;
+                avoidImplicitDeselect: boolean;
+                onDeselect: (event: import("sortablejs").SortableEvent) => void;
+                revertOnSpill: boolean;
+                removeOnSpill: boolean;
+                onSpill: (evt: import("sortablejs").SortableEvent) => void;
+                swap: boolean;
+                swapClass: string;
+                onAfterEnd: <T = any, R = any>(params: T) => R;
+            };
+        }, {}>;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("delete" | "change" | "register")[], "delete" | "change" | "register", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        previewFileList: {
+            type: import("vue").PropType<string[]>;
+            default: () => any[];
+        };
+        listType: {
+            type: import("vue").PropType<"picture" | "text" | "picture-card">;
+            default: string;
+        };
+        helpText: {
+            type: import("vue").PropType<string>;
+            default: string;
+        };
+        maxSize: {
+            type: import("vue").PropType<number>;
+            default: number;
+        };
+        maxNumber: {
+            type: import("vue").PropType<number>;
+            default: number;
+        };
+        accept: {
+            type: import("vue").PropType<string[]>;
+            default: () => any[];
+        };
+        multiple: {
+            type: import("vue").PropType<boolean>;
+            default: boolean;
+        };
+        uploadParams: {
+            type: import("vue").PropType<any>;
+            default: () => {};
+        };
+        api: {
+            type: import("vue").PropType<PromiseFn<any, any>>;
+            default: any;
+            required: boolean;
+        };
+        name: {
+            type: import("vue").PropType<string>;
+            default: string;
+        };
+        filename: {
+            type: import("vue").PropType<string>;
+            default: any;
+        };
+        fileListOpenDrag: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        fileListDragOptions: {
+            type: import("vue").PropType<{
+                scroll: boolean | HTMLElement;
+                filter: string | ((this: import("sortablejs"), event: Event | TouchEvent, target: HTMLElement, sortable: import("sortablejs")) => boolean);
+                sort: boolean;
+                onChange: (evt: import("sortablejs").SortableEvent) => void;
+                onSelect: (event: import("sortablejs").SortableEvent) => void;
+                disabled: boolean;
+                direction: ((evt: import("sortablejs").SortableEvent, target: HTMLElement, dragEl: HTMLElement) => import("sortablejs").Direction) | import("sortablejs").Direction;
+                draggable: string;
+                group: string | import("sortablejs").GroupOptions;
+                animation: number;
+                chosenClass: string;
+                dataIdAttr: string;
+                delay: number;
+                delayOnTouchOnly: boolean;
+                dragClass: string;
+                dragoverBubble: boolean;
+                dropBubble: boolean;
+                emptyInsertThreshold: number;
+                easing: string;
+                fallbackClass: string;
+                fallbackOnBody: boolean;
+                fallbackTolerance: number;
+                fallbackOffset: {
+                    x: number;
+                    y: number;
+                };
+                forceFallback: boolean;
+                ghostClass: string;
+                handle: string;
+                ignore: string;
+                invertSwap: boolean;
+                invertedSwapThreshold: number;
+                preventOnFilter: boolean;
+                removeCloneOnHide: boolean;
+                store: {
+                    get: (sortable: import("sortablejs")) => string[];
+                    set: (sortable: import("sortablejs")) => void;
+                };
+                swapThreshold: number;
+                touchStartThreshold: number;
+                setData: (dataTransfer: DataTransfer, draggedElement: HTMLElement) => void;
+                onStart: (event: import("sortablejs").SortableEvent) => void;
+                onAdd: (event: import("sortablejs").SortableEvent) => void;
+                onClone: (event: import("sortablejs").SortableEvent) => void;
+                onChoose: (event: import("sortablejs").SortableEvent) => void;
+                onUnchoose: (event: import("sortablejs").SortableEvent) => void;
+                onUpdate: (event: import("sortablejs").SortableEvent) => void;
+                onSort: (event: import("sortablejs").SortableEvent) => void;
+                onRemove: (event: import("sortablejs").SortableEvent) => void;
+                onFilter: (event: import("sortablejs").SortableEvent) => void;
+                onMove: (evt: import("sortablejs").MoveEvent, originalEvent: Event) => boolean | void | 1 | -1;
+                forceAutoScrollFallback: boolean;
+                scrollFn: (this: import("sortablejs"), offsetX: number, offsetY: number, originalEvent: Event, touchEvt: TouchEvent, hoverTargetEl: HTMLElement) => void | "continue";
+                scrollSensitivity: number;
+                scrollSpeed: number;
+                bubbleScroll: boolean;
+                multiDrag: boolean;
+                selectedClass: string;
+                multiDragKey: string;
+                avoidImplicitDeselect: boolean;
+                onDeselect: (event: import("sortablejs").SortableEvent) => void;
+                revertOnSpill: boolean;
+                removeOnSpill: boolean;
+                onSpill: (evt: import("sortablejs").SortableEvent) => void;
+                swap: boolean;
+                swapClass: string;
+                onAfterEnd: <T = any, R = any>(params: T) => R;
+            }>;
+            default: () => {};
+        };
+    }>> & {
+        onChange?: (...args: any[]) => any;
+        onRegister?: (...args: any[]) => any;
+        onDelete?: (...args: any[]) => any;
+    }, {
+        name: string;
+        api: PromiseFn<any, any>;
+        listType: "picture" | "text" | "picture-card";
+        helpText: string;
+        maxSize: number;
+        maxNumber: number;
+        accept: string[];
+        multiple: boolean;
+        uploadParams: any;
+        filename: string;
+        fileListOpenDrag: boolean;
+        fileListDragOptions: {
+            scroll: boolean | HTMLElement;
+            filter: string | ((this: import("sortablejs"), event: Event | TouchEvent, target: HTMLElement, sortable: import("sortablejs")) => boolean);
+            sort: boolean;
+            onChange: (evt: import("sortablejs").SortableEvent) => void;
+            onSelect: (event: import("sortablejs").SortableEvent) => void;
+            disabled: boolean;
+            direction: ((evt: import("sortablejs").SortableEvent, target: HTMLElement, dragEl: HTMLElement) => import("sortablejs").Direction) | import("sortablejs").Direction;
+            draggable: string;
+            group: string | import("sortablejs").GroupOptions;
+            animation: number;
+            chosenClass: string;
+            dataIdAttr: string;
+            delay: number;
+            delayOnTouchOnly: boolean;
+            dragClass: string;
+            dragoverBubble: boolean;
+            dropBubble: boolean;
+            emptyInsertThreshold: number;
+            easing: string;
+            fallbackClass: string;
+            fallbackOnBody: boolean;
+            fallbackTolerance: number;
+            fallbackOffset: {
+                x: number;
+                y: number;
+            };
+            forceFallback: boolean;
+            ghostClass: string;
+            handle: string;
+            ignore: string;
+            invertSwap: boolean;
+            invertedSwapThreshold: number;
+            preventOnFilter: boolean;
+            removeCloneOnHide: boolean;
+            store: {
+                get: (sortable: import("sortablejs")) => string[];
+                set: (sortable: import("sortablejs")) => void;
+            };
+            swapThreshold: number;
+            touchStartThreshold: number;
+            setData: (dataTransfer: DataTransfer, draggedElement: HTMLElement) => void;
+            onStart: (event: import("sortablejs").SortableEvent) => void;
+            onAdd: (event: import("sortablejs").SortableEvent) => void;
+            onClone: (event: import("sortablejs").SortableEvent) => void;
+            onChoose: (event: import("sortablejs").SortableEvent) => void;
+            onUnchoose: (event: import("sortablejs").SortableEvent) => void;
+            onUpdate: (event: import("sortablejs").SortableEvent) => void;
+            onSort: (event: import("sortablejs").SortableEvent) => void;
+            onRemove: (event: import("sortablejs").SortableEvent) => void;
+            onFilter: (event: import("sortablejs").SortableEvent) => void;
+            onMove: (evt: import("sortablejs").MoveEvent, originalEvent: Event) => boolean | void | 1 | -1;
+            forceAutoScrollFallback: boolean;
+            scrollFn: (this: import("sortablejs"), offsetX: number, offsetY: number, originalEvent: Event, touchEvt: TouchEvent, hoverTargetEl: HTMLElement) => void | "continue";
+            scrollSensitivity: number;
+            scrollSpeed: number;
+            bubbleScroll: boolean;
+            multiDrag: boolean;
+            selectedClass: string;
+            multiDragKey: string;
+            avoidImplicitDeselect: boolean;
+            onDeselect: (event: import("sortablejs").SortableEvent) => void;
+            revertOnSpill: boolean;
+            removeOnSpill: boolean;
+            onSpill: (evt: import("sortablejs").SortableEvent) => void;
+            swap: boolean;
+            swapClass: string;
+            onAfterEnd: <T = any, R = any>(params: T) => R;
+        };
+        previewFileList: string[];
+    }, {}>;
+    UploadPreviewModal: import("vue").DefineComponent<{
+        value: {
+            type: import("vue").PropType<string[]>;
+            default: () => any[];
+        };
+    }, {
+        props: any;
+        emit: (event: "delete" | "register" | "list-change", ...args: any[]) => void;
+        columns: any[];
+        actionColumn: any;
+        register: import("../../Modal").RegisterFn;
+        t: (key: any) => any;
+        fileListRef: import("vue").Ref<{
+            url: string;
+            name: string;
+            type: string;
+        }[]>;
+        handleRemove: (record: import("./types/typing").PreviewFileItem) => void;
+        handleDownload: (record: import("./types/typing").PreviewFileItem) => void;
+        readonly FileList: import("vue").DefineComponent<{
+            columns: {
+                type: import("vue").PropType<import("./types/typing").FileBasicColumn[]>;
+                default: any;
+            };
+            actionColumn: {
+                type: import("vue").PropType<import("./types/typing").FileBasicColumn>;
+                default: any;
+            };
+            dataSource: {
+                type: import("vue").PropType<any[]>;
+                default: any;
+            };
+            openDrag: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            dragOptions: {
+                type: import("vue").PropType<{
+                    scroll: boolean | HTMLElement;
+                    filter: string | ((this: import("sortablejs"), event: Event | TouchEvent, target: HTMLElement, sortable: import("sortablejs")) => boolean);
+                    sort: boolean;
+                    onChange: (evt: import("sortablejs").SortableEvent) => void;
+                    onSelect: (event: import("sortablejs").SortableEvent) => void;
+                    disabled: boolean;
+                    direction: ((evt: import("sortablejs").SortableEvent, target: HTMLElement, dragEl: HTMLElement) => import("sortablejs").Direction) | import("sortablejs").Direction;
+                    draggable: string;
+                    group: string | import("sortablejs").GroupOptions;
+                    animation: number;
+                    chosenClass: string;
+                    dataIdAttr: string;
+                    delay: number;
+                    delayOnTouchOnly: boolean;
+                    dragClass: string;
+                    dragoverBubble: boolean;
+                    dropBubble: boolean;
+                    emptyInsertThreshold: number;
+                    easing: string;
+                    fallbackClass: string;
+                    fallbackOnBody: boolean;
+                    fallbackTolerance: number;
+                    fallbackOffset: {
+                        x: number;
+                        y: number;
+                    };
+                    forceFallback: boolean;
+                    ghostClass: string;
+                    handle: string;
+                    ignore: string;
+                    invertSwap: boolean;
+                    invertedSwapThreshold: number;
+                    preventOnFilter: boolean;
+                    removeCloneOnHide: boolean;
+                    store: {
+                        get: (sortable: import("sortablejs")) => string[];
+                        set: (sortable: import("sortablejs")) => void;
+                    };
+                    swapThreshold: number;
+                    touchStartThreshold: number;
+                    setData: (dataTransfer: DataTransfer, draggedElement: HTMLElement) => void;
+                    onStart: (event: import("sortablejs").SortableEvent) => void;
+                    onAdd: (event: import("sortablejs").SortableEvent) => void;
+                    onClone: (event: import("sortablejs").SortableEvent) => void;
+                    onChoose: (event: import("sortablejs").SortableEvent) => void;
+                    onUnchoose: (event: import("sortablejs").SortableEvent) => void;
+                    onUpdate: (event: import("sortablejs").SortableEvent) => void;
+                    onSort: (event: import("sortablejs").SortableEvent) => void;
+                    onRemove: (event: import("sortablejs").SortableEvent) => void;
+                    onFilter: (event: import("sortablejs").SortableEvent) => void;
+                    onMove: (evt: import("sortablejs").MoveEvent, originalEvent: Event) => boolean | void | 1 | -1;
+                    forceAutoScrollFallback: boolean;
+                    scrollFn: (this: import("sortablejs"), offsetX: number, offsetY: number, originalEvent: Event, touchEvt: TouchEvent, hoverTargetEl: HTMLElement) => void | "continue";
+                    scrollSensitivity: number;
+                    scrollSpeed: number;
+                    bubbleScroll: boolean;
+                    multiDrag: boolean;
+                    selectedClass: string;
+                    multiDragKey: string;
+                    avoidImplicitDeselect: boolean;
+                    onDeselect: (event: import("sortablejs").SortableEvent) => void;
+                    revertOnSpill: boolean;
+                    removeOnSpill: boolean;
+                    onSpill: (evt: import("sortablejs").SortableEvent) => void;
+                    swap: boolean;
+                    swapClass: string;
+                    onAfterEnd: <T = any, R = any>(params: T) => R;
+                }>;
+                default: () => {};
+            };
+        }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            columns: {
+                type: import("vue").PropType<import("./types/typing").FileBasicColumn[]>;
+                default: any;
+            };
+            actionColumn: {
+                type: import("vue").PropType<import("./types/typing").FileBasicColumn>;
+                default: any;
+            };
+            dataSource: {
+                type: import("vue").PropType<any[]>;
+                default: any;
+            };
+            openDrag: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            dragOptions: {
+                type: import("vue").PropType<{
+                    scroll: boolean | HTMLElement;
+                    filter: string | ((this: import("sortablejs"), event: Event | TouchEvent, target: HTMLElement, sortable: import("sortablejs")) => boolean);
+                    sort: boolean;
+                    onChange: (evt: import("sortablejs").SortableEvent) => void;
+                    onSelect: (event: import("sortablejs").SortableEvent) => void;
+                    disabled: boolean;
+                    direction: ((evt: import("sortablejs").SortableEvent, target: HTMLElement, dragEl: HTMLElement) => import("sortablejs").Direction) | import("sortablejs").Direction;
+                    draggable: string;
+                    group: string | import("sortablejs").GroupOptions;
+                    animation: number;
+                    chosenClass: string;
+                    dataIdAttr: string;
+                    delay: number;
+                    delayOnTouchOnly: boolean;
+                    dragClass: string;
+                    dragoverBubble: boolean;
+                    dropBubble: boolean;
+                    emptyInsertThreshold: number;
+                    easing: string;
+                    fallbackClass: string;
+                    fallbackOnBody: boolean;
+                    fallbackTolerance: number;
+                    fallbackOffset: {
+                        x: number;
+                        y: number;
+                    };
+                    forceFallback: boolean;
+                    ghostClass: string;
+                    handle: string;
+                    ignore: string;
+                    invertSwap: boolean;
+                    invertedSwapThreshold: number;
+                    preventOnFilter: boolean;
+                    removeCloneOnHide: boolean;
+                    store: {
+                        get: (sortable: import("sortablejs")) => string[];
+                        set: (sortable: import("sortablejs")) => void;
+                    };
+                    swapThreshold: number;
+                    touchStartThreshold: number;
+                    setData: (dataTransfer: DataTransfer, draggedElement: HTMLElement) => void;
+                    onStart: (event: import("sortablejs").SortableEvent) => void;
+                    onAdd: (event: import("sortablejs").SortableEvent) => void;
+                    onClone: (event: import("sortablejs").SortableEvent) => void;
+                    onChoose: (event: import("sortablejs").SortableEvent) => void;
+                    onUnchoose: (event: import("sortablejs").SortableEvent) => void;
+                    onUpdate: (event: import("sortablejs").SortableEvent) => void;
+                    onSort: (event: import("sortablejs").SortableEvent) => void;
+                    onRemove: (event: import("sortablejs").SortableEvent) => void;
+                    onFilter: (event: import("sortablejs").SortableEvent) => void;
+                    onMove: (evt: import("sortablejs").MoveEvent, originalEvent: Event) => boolean | void | 1 | -1;
+                    forceAutoScrollFallback: boolean;
+                    scrollFn: (this: import("sortablejs"), offsetX: number, offsetY: number, originalEvent: Event, touchEvt: TouchEvent, hoverTargetEl: HTMLElement) => void | "continue";
+                    scrollSensitivity: number;
+                    scrollSpeed: number;
+                    bubbleScroll: boolean;
+                    multiDrag: boolean;
+                    selectedClass: string;
+                    multiDragKey: string;
+                    avoidImplicitDeselect: boolean;
+                    onDeselect: (event: import("sortablejs").SortableEvent) => void;
+                    revertOnSpill: boolean;
+                    removeOnSpill: boolean;
+                    onSpill: (evt: import("sortablejs").SortableEvent) => void;
+                    swap: boolean;
+                    swapClass: string;
+                    onAfterEnd: <T = any, R = any>(params: T) => R;
+                }>;
+                default: () => {};
+            };
+        }>>, {
+            columns: import("./types/typing").FileBasicColumn[];
+            dataSource: any[];
+            actionColumn: import("./types/typing").FileBasicColumn;
+            openDrag: boolean;
+            dragOptions: {
+                scroll: boolean | HTMLElement;
+                filter: string | ((this: import("sortablejs"), event: Event | TouchEvent, target: HTMLElement, sortable: import("sortablejs")) => boolean);
+                sort: boolean;
+                onChange: (evt: import("sortablejs").SortableEvent) => void;
+                onSelect: (event: import("sortablejs").SortableEvent) => void;
+                disabled: boolean;
+                direction: ((evt: import("sortablejs").SortableEvent, target: HTMLElement, dragEl: HTMLElement) => import("sortablejs").Direction) | import("sortablejs").Direction;
+                draggable: string;
+                group: string | import("sortablejs").GroupOptions;
+                animation: number;
+                chosenClass: string;
+                dataIdAttr: string;
+                delay: number;
+                delayOnTouchOnly: boolean;
+                dragClass: string;
+                dragoverBubble: boolean;
+                dropBubble: boolean;
+                emptyInsertThreshold: number;
+                easing: string;
+                fallbackClass: string;
+                fallbackOnBody: boolean;
+                fallbackTolerance: number;
+                fallbackOffset: {
+                    x: number;
+                    y: number;
+                };
+                forceFallback: boolean;
+                ghostClass: string;
+                handle: string;
+                ignore: string;
+                invertSwap: boolean;
+                invertedSwapThreshold: number;
+                preventOnFilter: boolean;
+                removeCloneOnHide: boolean;
+                store: {
+                    get: (sortable: import("sortablejs")) => string[];
+                    set: (sortable: import("sortablejs")) => void;
+                };
+                swapThreshold: number;
+                touchStartThreshold: number;
+                setData: (dataTransfer: DataTransfer, draggedElement: HTMLElement) => void;
+                onStart: (event: import("sortablejs").SortableEvent) => void;
+                onAdd: (event: import("sortablejs").SortableEvent) => void;
+                onClone: (event: import("sortablejs").SortableEvent) => void;
+                onChoose: (event: import("sortablejs").SortableEvent) => void;
+                onUnchoose: (event: import("sortablejs").SortableEvent) => void;
+                onUpdate: (event: import("sortablejs").SortableEvent) => void;
+                onSort: (event: import("sortablejs").SortableEvent) => void;
+                onRemove: (event: import("sortablejs").SortableEvent) => void;
+                onFilter: (event: import("sortablejs").SortableEvent) => void;
+                onMove: (evt: import("sortablejs").MoveEvent, originalEvent: Event) => boolean | void | 1 | -1;
+                forceAutoScrollFallback: boolean;
+                scrollFn: (this: import("sortablejs"), offsetX: number, offsetY: number, originalEvent: Event, touchEvt: TouchEvent, hoverTargetEl: HTMLElement) => void | "continue";
+                scrollSensitivity: number;
+                scrollSpeed: number;
+                bubbleScroll: boolean;
+                multiDrag: boolean;
+                selectedClass: string;
+                multiDragKey: string;
+                avoidImplicitDeselect: boolean;
+                onDeselect: (event: import("sortablejs").SortableEvent) => void;
+                revertOnSpill: boolean;
+                removeOnSpill: boolean;
+                onSpill: (evt: import("sortablejs").SortableEvent) => void;
+                swap: boolean;
+                swapClass: string;
+                onAfterEnd: <T = any, R = any>(params: T) => R;
+            };
+        }, {}>;
+        readonly BasicModal: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
+                defaultFullscreen: {
+                    type: BooleanConstructor;
+                };
+                canFullscreen: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                wrapperFooterOffset: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                helpMessage: ((new (...args: any[]) => string | string[]) | (() => string | string[])) | ((new (...args: any[]) => string | string[]) | (() => string | string[]))[];
+                useWrapper: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                loading: {
+                    type: BooleanConstructor;
+                };
+                loadingTip: {
+                    type: StringConstructor;
+                };
+                showCancelBtn: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                showOkBtn: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                wrapperProps: ((new (...args: any[]) => Partial<import("../../Modal").ModalWrapperProps>) | (() => Partial<import("../../Modal").ModalWrapperProps>)) | ((new (...args: any[]) => Partial<import("../../Modal").ModalWrapperProps>) | (() => Partial<import("../../Modal").ModalWrapperProps>))[];
+                afterClose: ((new (...args: any[]) => () => Promise<VueNode>) | (() => () => Promise<VueNode>) | {
+                    (): () => Promise<VueNode>;
+                    new (): any;
+                    readonly prototype: any;
+                }) | ((new (...args: any[]) => () => Promise<VueNode>) | (() => () => Promise<VueNode>) | {
+                    (): () => Promise<VueNode>;
+                    new (): any;
+                    readonly prototype: any;
+                })[];
+                bodyStyle: ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties)) | ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties))[];
+                closable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                closeIcon: ((new (...args: any[]) => VueNode & {}) | (() => VueNode)) | ((new (...args: any[]) => VueNode & {}) | (() => VueNode))[];
+                confirmLoading: {
+                    type: BooleanConstructor;
+                };
+                destroyOnClose: {
+                    type: BooleanConstructor;
+                };
+                footer: ((new (...args: any[]) => VueNode & {}) | (() => VueNode)) | ((new (...args: any[]) => VueNode & {}) | (() => VueNode))[];
+                getContainer: ((new (...args: any[]) => () => any) | (() => () => any) | {
+                    (): () => any;
+                    new (): any;
+                    readonly prototype: any;
+                }) | ((new (...args: any[]) => () => any) | (() => () => any) | {
+                    (): () => any;
+                    new (): any;
+                    readonly prototype: any;
+                })[];
+                mask: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maskClosable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                keyboard: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maskStyle: ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties)) | ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties))[];
+                okType: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                okButtonProps: {
+                    type: ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>)) | ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>))[];
+                };
+                cancelButtonProps: {
+                    type: ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>)) | ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>))[];
+                };
+                title: {
+                    type: StringConstructor;
+                };
+                visible: {
+                    type: BooleanConstructor;
+                };
+                width: ((new (...args: any[]) => string | number) | (() => string | number)) | ((new (...args: any[]) => string | number) | (() => string | number))[];
+                wrapClassName: {
+                    type: StringConstructor;
+                };
+                zIndex: {
+                    type: NumberConstructor;
+                };
+                size: {
+                    type: ((new (...args: any[]) => "small" | "default" | "large") | (() => "small" | "default" | "large")) | ((new (...args: any[]) => "small" | "default" | "large") | (() => "small" | "default" | "large"))[];
+                    default: string;
+                };
+                scrollTop: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                height: {
+                    type: NumberConstructor;
+                };
+                minHeight: {
+                    type: NumberConstructor;
+                };
+                draggable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                centered: {
+                    type: BooleanConstructor;
+                };
+                cancelText: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                okText: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                closeFunc: ((new (...args: any[]) => () => Promise<boolean>) | (() => () => Promise<boolean>) | {
+                    (): () => Promise<boolean>;
+                    new (): any;
+                    readonly prototype: any;
+                }) | ((new (...args: any[]) => () => Promise<boolean>) | (() => () => Promise<boolean>) | {
+                    (): () => Promise<boolean>;
+                    new (): any;
+                    readonly prototype: any;
+                })[];
+            }>> & {
+                onCancel?: (...args: any[]) => any;
+                "onHeight-change"?: (...args: any[]) => any;
+                onOk?: (...args: any[]) => any;
+                "onVisible-change"?: (...args: any[]) => any;
+                onRegister?: (...args: any[]) => any;
+                "onUpdate:visible"?: (...args: any[]) => any;
+            }, {
+                prefixCls: string;
+                handleCancel: (e: Event) => Promise<void>;
+                getBindValue: import("vue").ComputedRef<Recordable<any>>;
+                getProps: import("vue").ComputedRef<Recordable<any>>;
+                handleFullScreen: (e: Event) => void;
+                fullScreenRef: import("vue").Ref<boolean>;
+                getMergeProps: import("vue").ComputedRef<Recordable<any>>;
+                handleOk: (e: Event) => void;
+                visibleRef: import("vue").Ref<boolean>;
+                omitBindValue: Object;
+                omitSlotKeys: import("vue").ComputedRef<string[]>;
+                modalWrapperRef: import("vue").Ref<any>;
+                handleExtHeight: (height: number) => void;
+                handleHeightChange: (height: string) => void;
+                handleTitleDbClick: (e: Event) => void;
+                getWrapperHeight: import("vue").ComputedRef<any>;
+            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("cancel" | "height-change" | "ok" | "visible-change" | "register" | "update:visible")[], import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+                defaultFullscreen: {
+                    type: BooleanConstructor;
+                };
+                canFullscreen: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                wrapperFooterOffset: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                helpMessage: ((new (...args: any[]) => string | string[]) | (() => string | string[])) | ((new (...args: any[]) => string | string[]) | (() => string | string[]))[];
+                useWrapper: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                loading: {
+                    type: BooleanConstructor;
+                };
+                loadingTip: {
+                    type: StringConstructor;
+                };
+                showCancelBtn: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                showOkBtn: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                wrapperProps: ((new (...args: any[]) => Partial<import("../../Modal").ModalWrapperProps>) | (() => Partial<import("../../Modal").ModalWrapperProps>)) | ((new (...args: any[]) => Partial<import("../../Modal").ModalWrapperProps>) | (() => Partial<import("../../Modal").ModalWrapperProps>))[];
+                afterClose: ((new (...args: any[]) => () => Promise<VueNode>) | (() => () => Promise<VueNode>) | {
+                    (): () => Promise<VueNode>;
+                    new (): any;
+                    readonly prototype: any;
+                }) | ((new (...args: any[]) => () => Promise<VueNode>) | (() => () => Promise<VueNode>) | {
+                    (): () => Promise<VueNode>;
+                    new (): any;
+                    readonly prototype: any;
+                })[];
+                bodyStyle: ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties)) | ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties))[];
+                closable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                closeIcon: ((new (...args: any[]) => VueNode & {}) | (() => VueNode)) | ((new (...args: any[]) => VueNode & {}) | (() => VueNode))[];
+                confirmLoading: {
+                    type: BooleanConstructor;
+                };
+                destroyOnClose: {
+                    type: BooleanConstructor;
+                };
+                footer: ((new (...args: any[]) => VueNode & {}) | (() => VueNode)) | ((new (...args: any[]) => VueNode & {}) | (() => VueNode))[];
+                getContainer: ((new (...args: any[]) => () => any) | (() => () => any) | {
+                    (): () => any;
+                    new (): any;
+                    readonly prototype: any;
+                }) | ((new (...args: any[]) => () => any) | (() => () => any) | {
+                    (): () => any;
+                    new (): any;
+                    readonly prototype: any;
+                })[];
+                mask: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maskClosable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                keyboard: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maskStyle: ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties)) | ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties))[];
+                okType: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                okButtonProps: {
+                    type: ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>)) | ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>))[];
+                };
+                cancelButtonProps: {
+                    type: ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>)) | ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>))[];
+                };
+                title: {
+                    type: StringConstructor;
+                };
+                visible: {
+                    type: BooleanConstructor;
+                };
+                width: ((new (...args: any[]) => string | number) | (() => string | number)) | ((new (...args: any[]) => string | number) | (() => string | number))[];
+                wrapClassName: {
+                    type: StringConstructor;
+                };
+                zIndex: {
+                    type: NumberConstructor;
+                };
+                size: {
+                    type: ((new (...args: any[]) => "small" | "default" | "large") | (() => "small" | "default" | "large")) | ((new (...args: any[]) => "small" | "default" | "large") | (() => "small" | "default" | "large"))[];
+                    default: string;
+                };
+                scrollTop: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                height: {
+                    type: NumberConstructor;
+                };
+                minHeight: {
+                    type: NumberConstructor;
+                };
+                draggable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                centered: {
+                    type: BooleanConstructor;
+                };
+                cancelText: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                okText: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                closeFunc: ((new (...args: any[]) => () => Promise<boolean>) | (() => () => Promise<boolean>) | {
+                    (): () => Promise<boolean>;
+                    new (): any;
+                    readonly prototype: any;
+                }) | ((new (...args: any[]) => () => Promise<boolean>) | (() => () => Promise<boolean>) | {
+                    (): () => Promise<boolean>;
+                    new (): any;
+                    readonly prototype: any;
+                })[];
+            }>> & {
+                onCancel?: (...args: any[]) => any;
+                "onHeight-change"?: (...args: any[]) => any;
+                onOk?: (...args: any[]) => any;
+                "onVisible-change"?: (...args: any[]) => any;
+                onRegister?: (...args: any[]) => any;
+                "onUpdate:visible"?: (...args: any[]) => any;
+            }, {
+                size: "small" | "default" | "large";
+                mask: boolean;
+                loading: boolean;
+                defaultFullscreen: boolean;
+                canFullscreen: boolean;
+                wrapperFooterOffset: number;
+                useWrapper: boolean;
+                showCancelBtn: boolean;
+                showOkBtn: boolean;
+                visible: boolean;
+                closable: boolean;
+                confirmLoading: boolean;
+                destroyOnClose: boolean;
+                maskClosable: boolean;
+                keyboard: boolean;
+                okType: string;
+                scrollTop: boolean;
+                draggable: boolean;
+                centered: boolean;
+                cancelText: string;
+                okText: string;
+            }, true, {}, {}, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("vue").ExtractPropTypes<{
+                defaultFullscreen: {
+                    type: BooleanConstructor;
+                };
+                canFullscreen: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                wrapperFooterOffset: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                helpMessage: ((new (...args: any[]) => string | string[]) | (() => string | string[])) | ((new (...args: any[]) => string | string[]) | (() => string | string[]))[];
+                useWrapper: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                loading: {
+                    type: BooleanConstructor;
+                };
+                loadingTip: {
+                    type: StringConstructor;
+                };
+                showCancelBtn: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                showOkBtn: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                wrapperProps: ((new (...args: any[]) => Partial<import("../../Modal").ModalWrapperProps>) | (() => Partial<import("../../Modal").ModalWrapperProps>)) | ((new (...args: any[]) => Partial<import("../../Modal").ModalWrapperProps>) | (() => Partial<import("../../Modal").ModalWrapperProps>))[];
+                afterClose: ((new (...args: any[]) => () => Promise<VueNode>) | (() => () => Promise<VueNode>) | {
+                    (): () => Promise<VueNode>;
+                    new (): any;
+                    readonly prototype: any;
+                }) | ((new (...args: any[]) => () => Promise<VueNode>) | (() => () => Promise<VueNode>) | {
+                    (): () => Promise<VueNode>;
+                    new (): any;
+                    readonly prototype: any;
+                })[];
+                bodyStyle: ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties)) | ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties))[];
+                closable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                closeIcon: ((new (...args: any[]) => VueNode & {}) | (() => VueNode)) | ((new (...args: any[]) => VueNode & {}) | (() => VueNode))[];
+                confirmLoading: {
+                    type: BooleanConstructor;
+                };
+                destroyOnClose: {
+                    type: BooleanConstructor;
+                };
+                footer: ((new (...args: any[]) => VueNode & {}) | (() => VueNode)) | ((new (...args: any[]) => VueNode & {}) | (() => VueNode))[];
+                getContainer: ((new (...args: any[]) => () => any) | (() => () => any) | {
+                    (): () => any;
+                    new (): any;
+                    readonly prototype: any;
+                }) | ((new (...args: any[]) => () => any) | (() => () => any) | {
+                    (): () => any;
+                    new (): any;
+                    readonly prototype: any;
+                })[];
+                mask: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maskClosable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                keyboard: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maskStyle: ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties)) | ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties))[];
+                okType: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                okButtonProps: {
+                    type: ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>)) | ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>))[];
+                };
+                cancelButtonProps: {
+                    type: ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>)) | ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>))[];
+                };
+                title: {
+                    type: StringConstructor;
+                };
+                visible: {
+                    type: BooleanConstructor;
+                };
+                width: ((new (...args: any[]) => string | number) | (() => string | number)) | ((new (...args: any[]) => string | number) | (() => string | number))[];
+                wrapClassName: {
+                    type: StringConstructor;
+                };
+                zIndex: {
+                    type: NumberConstructor;
+                };
+                size: {
+                    type: ((new (...args: any[]) => "small" | "default" | "large") | (() => "small" | "default" | "large")) | ((new (...args: any[]) => "small" | "default" | "large") | (() => "small" | "default" | "large"))[];
+                    default: string;
+                };
+                scrollTop: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                height: {
+                    type: NumberConstructor;
+                };
+                minHeight: {
+                    type: NumberConstructor;
+                };
+                draggable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                centered: {
+                    type: BooleanConstructor;
+                };
+                cancelText: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                okText: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                closeFunc: ((new (...args: any[]) => () => Promise<boolean>) | (() => () => Promise<boolean>) | {
+                    (): () => Promise<boolean>;
+                    new (): any;
+                    readonly prototype: any;
+                }) | ((new (...args: any[]) => () => Promise<boolean>) | (() => () => Promise<boolean>) | {
+                    (): () => Promise<boolean>;
+                    new (): any;
+                    readonly prototype: any;
+                })[];
+            }>> & {
+                onCancel?: (...args: any[]) => any;
+                "onHeight-change"?: (...args: any[]) => any;
+                onOk?: (...args: any[]) => any;
+                "onVisible-change"?: (...args: any[]) => any;
+                onRegister?: (...args: any[]) => any;
+                "onUpdate:visible"?: (...args: any[]) => any;
+            }, {
+                prefixCls: string;
+                handleCancel: (e: Event) => Promise<void>;
+                getBindValue: import("vue").ComputedRef<Recordable<any>>;
+                getProps: import("vue").ComputedRef<Recordable<any>>;
+                handleFullScreen: (e: Event) => void;
+                fullScreenRef: import("vue").Ref<boolean>;
+                getMergeProps: import("vue").ComputedRef<Recordable<any>>;
+                handleOk: (e: Event) => void;
+                visibleRef: import("vue").Ref<boolean>;
+                omitBindValue: Object;
+                omitSlotKeys: import("vue").ComputedRef<string[]>;
+                modalWrapperRef: import("vue").Ref<any>;
+                handleExtHeight: (height: number) => void;
+                handleHeightChange: (height: string) => void;
+                handleTitleDbClick: (e: Event) => void;
+                getWrapperHeight: import("vue").ComputedRef<any>;
+            }, {}, {}, {}, {
+                size: "small" | "default" | "large";
+                mask: boolean;
+                loading: boolean;
+                defaultFullscreen: boolean;
+                canFullscreen: boolean;
+                wrapperFooterOffset: number;
+                useWrapper: boolean;
+                showCancelBtn: boolean;
+                showOkBtn: boolean;
+                visible: boolean;
+                closable: boolean;
+                confirmLoading: boolean;
+                destroyOnClose: boolean;
+                maskClosable: boolean;
+                keyboard: boolean;
+                okType: string;
+                scrollTop: boolean;
+                draggable: boolean;
+                centered: boolean;
+                cancelText: string;
+                okText: string;
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            defaultFullscreen: {
+                type: BooleanConstructor;
+            };
+            canFullscreen: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            wrapperFooterOffset: {
+                type: NumberConstructor;
+                default: number;
+            };
+            helpMessage: ((new (...args: any[]) => string | string[]) | (() => string | string[])) | ((new (...args: any[]) => string | string[]) | (() => string | string[]))[];
+            useWrapper: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            loading: {
+                type: BooleanConstructor;
+            };
+            loadingTip: {
+                type: StringConstructor;
+            };
+            showCancelBtn: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            showOkBtn: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            wrapperProps: ((new (...args: any[]) => Partial<import("../../Modal").ModalWrapperProps>) | (() => Partial<import("../../Modal").ModalWrapperProps>)) | ((new (...args: any[]) => Partial<import("../../Modal").ModalWrapperProps>) | (() => Partial<import("../../Modal").ModalWrapperProps>))[];
+            afterClose: ((new (...args: any[]) => () => Promise<VueNode>) | (() => () => Promise<VueNode>) | {
+                (): () => Promise<VueNode>;
+                new (): any;
+                readonly prototype: any;
+            }) | ((new (...args: any[]) => () => Promise<VueNode>) | (() => () => Promise<VueNode>) | {
+                (): () => Promise<VueNode>;
+                new (): any;
+                readonly prototype: any;
+            })[];
+            bodyStyle: ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties)) | ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties))[];
+            closable: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            closeIcon: ((new (...args: any[]) => VueNode & {}) | (() => VueNode)) | ((new (...args: any[]) => VueNode & {}) | (() => VueNode))[];
+            confirmLoading: {
+                type: BooleanConstructor;
+            };
+            destroyOnClose: {
+                type: BooleanConstructor;
+            };
+            footer: ((new (...args: any[]) => VueNode & {}) | (() => VueNode)) | ((new (...args: any[]) => VueNode & {}) | (() => VueNode))[];
+            getContainer: ((new (...args: any[]) => () => any) | (() => () => any) | {
+                (): () => any;
+                new (): any;
+                readonly prototype: any;
+            }) | ((new (...args: any[]) => () => any) | (() => () => any) | {
+                (): () => any;
+                new (): any;
+                readonly prototype: any;
+            })[];
+            mask: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            maskClosable: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            keyboard: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            maskStyle: ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties)) | ((new (...args: any[]) => import("vue").CSSProperties) | (() => import("vue").CSSProperties))[];
+            okType: {
+                type: StringConstructor;
+                default: string;
+            };
+            okButtonProps: {
+                type: ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>)) | ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>))[];
+            };
+            cancelButtonProps: {
+                type: ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>)) | ((new (...args: any[]) => Recordable<any>) | (() => Recordable<any>))[];
+            };
+            title: {
+                type: StringConstructor;
+            };
+            visible: {
+                type: BooleanConstructor;
+            };
+            width: ((new (...args: any[]) => string | number) | (() => string | number)) | ((new (...args: any[]) => string | number) | (() => string | number))[];
+            wrapClassName: {
+                type: StringConstructor;
+            };
+            zIndex: {
+                type: NumberConstructor;
+            };
+            size: {
+                type: ((new (...args: any[]) => "small" | "default" | "large") | (() => "small" | "default" | "large")) | ((new (...args: any[]) => "small" | "default" | "large") | (() => "small" | "default" | "large"))[];
+                default: string;
+            };
+            scrollTop: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            height: {
+                type: NumberConstructor;
+            };
+            minHeight: {
+                type: NumberConstructor;
+            };
+            draggable: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            centered: {
+                type: BooleanConstructor;
+            };
+            cancelText: {
+                type: StringConstructor;
+                default: string;
+            };
+            okText: {
+                type: StringConstructor;
+                default: string;
+            };
+            closeFunc: ((new (...args: any[]) => () => Promise<boolean>) | (() => () => Promise<boolean>) | {
+                (): () => Promise<boolean>;
+                new (): any;
+                readonly prototype: any;
+            }) | ((new (...args: any[]) => () => Promise<boolean>) | (() => () => Promise<boolean>) | {
+                (): () => Promise<boolean>;
+                new (): any;
+                readonly prototype: any;
+            })[];
+        }>> & {
+            onCancel?: (...args: any[]) => any;
+            "onHeight-change"?: (...args: any[]) => any;
+            onOk?: (...args: any[]) => any;
+            "onVisible-change"?: (...args: any[]) => any;
+            onRegister?: (...args: any[]) => any;
+            "onUpdate:visible"?: (...args: any[]) => any;
+        }, {
+            prefixCls: string;
+            handleCancel: (e: Event) => Promise<void>;
+            getBindValue: import("vue").ComputedRef<Recordable<any>>;
+            getProps: import("vue").ComputedRef<Recordable<any>>;
+            handleFullScreen: (e: Event) => void;
+            fullScreenRef: import("vue").Ref<boolean>;
+            getMergeProps: import("vue").ComputedRef<Recordable<any>>;
+            handleOk: (e: Event) => void;
+            visibleRef: import("vue").Ref<boolean>;
+            omitBindValue: Object;
+            omitSlotKeys: import("vue").ComputedRef<string[]>;
+            modalWrapperRef: import("vue").Ref<any>;
+            handleExtHeight: (height: number) => void;
+            handleHeightChange: (height: string) => void;
+            handleTitleDbClick: (e: Event) => void;
+            getWrapperHeight: import("vue").ComputedRef<any>;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("cancel" | "height-change" | "ok" | "visible-change" | "register" | "update:visible")[], "cancel" | "height-change" | "ok" | "visible-change" | "register" | "update:visible", {
+            size: "small" | "default" | "large";
+            mask: boolean;
+            loading: boolean;
+            defaultFullscreen: boolean;
+            canFullscreen: boolean;
+            wrapperFooterOffset: number;
+            useWrapper: boolean;
+            showCancelBtn: boolean;
+            showOkBtn: boolean;
+            visible: boolean;
+            closable: boolean;
+            confirmLoading: boolean;
+            destroyOnClose: boolean;
+            maskClosable: boolean;
+            keyboard: boolean;
+            okType: string;
+            scrollTop: boolean;
+            draggable: boolean;
+            centered: boolean;
+            cancelText: string;
+            okText: string;
+        }, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin<any[]>;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("delete" | "register" | "list-change")[], "delete" | "register" | "list-change", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        value: {
+            type: import("vue").PropType<string[]>;
+            default: () => any[];
+        };
+    }>> & {
+        onRegister?: (...args: any[]) => any;
+        onDelete?: (...args: any[]) => any;
+        "onList-change"?: (...args: any[]) => any;
+    }, {
+        value: string[];
+    }, {}>;
+    readonly BasicButton: import("vue").DefineComponent<{
+        type: {
+            type: ((new (...args: any[]) => "link" | "default" | "message" | "primary" | "text" | "ghost" | "dashed" | "danger" | "waring" | "success") | (() => "link" | "default" | "message" | "primary" | "text" | "ghost" | "dashed" | "danger" | "waring" | "success")) | ((new (...args: any[]) => "link" | "default" | "message" | "primary" | "text" | "ghost" | "dashed" | "danger" | "waring" | "success") | (() => "link" | "default" | "message" | "primary" | "text" | "ghost" | "dashed" | "danger" | "waring" | "success"))[];
+            default: string;
+        };
+        color: {
+            type: ((new (...args: any[]) => "" | "error" | "success" | "warning") | (() => "" | "error" | "success" | "warning")) | ((new (...args: any[]) => "" | "error" | "success" | "warning") | (() => "" | "error" | "success" | "warning"))[];
+            validator: (v: any) => boolean;
+            default: string;
+        };
+        loading: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        disabled: {
+            type: BooleanConstructor;
+        };
+        preIcon: {
+            type: StringConstructor;
+        };
+        postIcon: {
+            type: StringConstructor;
+        };
+        iconSize: {
+            type: NumberConstructor;
+            default: number;
+        };
+        onClick: {
+            type: ((new (...args: any[]) => (...args: any[]) => any) | (() => (...args: any[]) => any) | {
+                (): (...args: any[]) => any;
+                new (): any;
+                readonly prototype: any;
+            }) | ((new (...args: any[]) => (...args: any[]) => any) | (() => (...args: any[]) => any) | {
+                (): (...args: any[]) => any;
+                new (): any;
+                readonly prototype: any;
+            })[];
+            default: any;
+        };
+        isContinuousClicks: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        closeConfigProvide: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        type: {
+            type: ((new (...args: any[]) => "link" | "default" | "message" | "primary" | "text" | "ghost" | "dashed" | "danger" | "waring" | "success") | (() => "link" | "default" | "message" | "primary" | "text" | "ghost" | "dashed" | "danger" | "waring" | "success")) | ((new (...args: any[]) => "link" | "default" | "message" | "primary" | "text" | "ghost" | "dashed" | "danger" | "waring" | "success") | (() => "link" | "default" | "message" | "primary" | "text" | "ghost" | "dashed" | "danger" | "waring" | "success"))[];
+            default: string;
+        };
+        color: {
+            type: ((new (...args: any[]) => "" | "error" | "success" | "warning") | (() => "" | "error" | "success" | "warning")) | ((new (...args: any[]) => "" | "error" | "success" | "warning") | (() => "" | "error" | "success" | "warning"))[];
+            validator: (v: any) => boolean;
+            default: string;
+        };
+        loading: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        disabled: {
+            type: BooleanConstructor;
+        };
+        preIcon: {
+            type: StringConstructor;
+        };
+        postIcon: {
+            type: StringConstructor;
+        };
+        iconSize: {
+            type: NumberConstructor;
+            default: number;
+        };
+        onClick: {
+            type: ((new (...args: any[]) => (...args: any[]) => any) | (() => (...args: any[]) => any) | {
+                (): (...args: any[]) => any;
+                new (): any;
+                readonly prototype: any;
+            }) | ((new (...args: any[]) => (...args: any[]) => any) | (() => (...args: any[]) => any) | {
+                (): (...args: any[]) => any;
+                new (): any;
+                readonly prototype: any;
+            })[];
+            default: any;
+        };
+        isContinuousClicks: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        closeConfigProvide: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>>, {
+        type: "link" | "default" | "message" | "primary" | "text" | "ghost" | "dashed" | "danger" | "waring" | "success";
+        onClick: (...args: any[]) => any;
+        disabled: boolean;
+        loading: boolean;
+        color: "" | "error" | "success" | "warning";
+        iconSize: number;
+        isContinuousClicks: boolean;
+        closeConfigProvide: boolean;
+    }, {}>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("delete" | "change" | "update:value" | "preview-delete")[], "delete" | "change" | "update:value" | "preview-delete", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    showPreviewNumber: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    emptyHidePreview: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    listType: {
+        type: import("vue").PropType<"picture" | "text" | "picture-card">;
+        default: string;
+    };
+    helpText: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    maxSize: {
+        type: import("vue").PropType<number>;
+        default: number;
+    };
+    maxNumber: {
+        type: import("vue").PropType<number>;
+        default: number;
+    };
+    accept: {
+        type: import("vue").PropType<string[]>;
+        default: () => any[];
+    };
+    multiple: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    uploadParams: {
+        type: import("vue").PropType<any>;
+        default: () => {};
+    };
+    api: {
+        type: import("vue").PropType<PromiseFn<any, any>>;
+        default: any;
+        required: boolean;
+    };
+    name: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    filename: {
+        type: import("vue").PropType<string>;
+        default: any;
+    };
+    fileListOpenDrag: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    fileListDragOptions: {
+        type: import("vue").PropType<{
+            scroll: boolean | HTMLElement;
+            filter: string | ((this: import("sortablejs"), event: Event | TouchEvent, target: HTMLElement, sortable: import("sortablejs")) => boolean);
+            sort: boolean;
+            onChange: (evt: import("sortablejs").SortableEvent) => void;
+            onSelect: (event: import("sortablejs").SortableEvent) => void;
+            disabled: boolean;
+            direction: ((evt: import("sortablejs").SortableEvent, target: HTMLElement, dragEl: HTMLElement) => import("sortablejs").Direction) | import("sortablejs").Direction;
+            draggable: string;
+            group: string | import("sortablejs").GroupOptions;
+            animation: number;
+            chosenClass: string;
+            dataIdAttr: string;
+            delay: number;
+            delayOnTouchOnly: boolean;
+            dragClass: string;
+            dragoverBubble: boolean;
+            dropBubble: boolean;
+            emptyInsertThreshold: number;
+            easing: string;
+            fallbackClass: string;
+            fallbackOnBody: boolean;
+            fallbackTolerance: number;
+            fallbackOffset: {
+                x: number;
+                y: number;
+            };
+            forceFallback: boolean;
+            ghostClass: string;
+            handle: string;
+            ignore: string;
+            invertSwap: boolean;
+            invertedSwapThreshold: number;
+            preventOnFilter: boolean;
+            removeCloneOnHide: boolean;
+            store: {
+                get: (sortable: import("sortablejs")) => string[];
+                set: (sortable: import("sortablejs")) => void;
+            };
+            swapThreshold: number;
+            touchStartThreshold: number;
+            setData: (dataTransfer: DataTransfer, draggedElement: HTMLElement) => void;
+            onStart: (event: import("sortablejs").SortableEvent) => void;
+            onAdd: (event: import("sortablejs").SortableEvent) => void;
+            onClone: (event: import("sortablejs").SortableEvent) => void;
+            onChoose: (event: import("sortablejs").SortableEvent) => void;
+            onUnchoose: (event: import("sortablejs").SortableEvent) => void;
+            onUpdate: (event: import("sortablejs").SortableEvent) => void;
+            onSort: (event: import("sortablejs").SortableEvent) => void;
+            onRemove: (event: import("sortablejs").SortableEvent) => void;
+            onFilter: (event: import("sortablejs").SortableEvent) => void;
+            onMove: (evt: import("sortablejs").MoveEvent, originalEvent: Event) => boolean | void | 1 | -1;
+            forceAutoScrollFallback: boolean;
+            scrollFn: (this: import("sortablejs"), offsetX: number, offsetY: number, originalEvent: Event, touchEvt: TouchEvent, hoverTargetEl: HTMLElement) => void | "continue";
+            scrollSensitivity: number;
+            scrollSpeed: number;
+            bubbleScroll: boolean;
+            multiDrag: boolean;
+            selectedClass: string;
+            multiDragKey: string;
+            avoidImplicitDeselect: boolean;
+            onDeselect: (event: import("sortablejs").SortableEvent) => void;
+            revertOnSpill: boolean;
+            removeOnSpill: boolean;
+            onSpill: (evt: import("sortablejs").SortableEvent) => void;
+            swap: boolean;
+            swapClass: string;
+            onAfterEnd: <T = any, R = any>(params: T) => R;
+        }>;
+        default: () => {};
+    };
+    value: {
+        type: import("vue").PropType<string[]>;
+        default: () => any[];
+    };
+}>> & {
+    onChange?: (...args: any[]) => any;
+    "onUpdate:value"?: (...args: any[]) => any;
+    onDelete?: (...args: any[]) => any;
+    "onPreview-delete"?: (...args: any[]) => any;
+}, {
+    value: string[];
+    name: string;
+    api: PromiseFn<any, any>;
+    showPreviewNumber: boolean;
+    emptyHidePreview: boolean;
+    listType: "picture" | "text" | "picture-card";
+    helpText: string;
+    maxSize: number;
+    maxNumber: number;
+    accept: string[];
+    multiple: boolean;
+    uploadParams: any;
+    filename: string;
+    fileListOpenDrag: boolean;
+    fileListDragOptions: {
+        scroll: boolean | HTMLElement;
+        filter: string | ((this: import("sortablejs"), event: Event | TouchEvent, target: HTMLElement, sortable: import("sortablejs")) => boolean);
+        sort: boolean;
+        onChange: (evt: import("sortablejs").SortableEvent) => void;
+        onSelect: (event: import("sortablejs").SortableEvent) => void;
+        disabled: boolean;
+        direction: ((evt: import("sortablejs").SortableEvent, target: HTMLElement, dragEl: HTMLElement) => import("sortablejs").Direction) | import("sortablejs").Direction;
+        draggable: string;
+        group: string | import("sortablejs").GroupOptions;
+        animation: number;
+        chosenClass: string;
+        dataIdAttr: string;
+        delay: number;
+        delayOnTouchOnly: boolean;
+        dragClass: string;
+        dragoverBubble: boolean;
+        dropBubble: boolean;
+        emptyInsertThreshold: number;
+        easing: string;
+        fallbackClass: string;
+        fallbackOnBody: boolean;
+        fallbackTolerance: number;
+        fallbackOffset: {
+            x: number;
+            y: number;
+        };
+        forceFallback: boolean;
+        ghostClass: string;
+        handle: string;
+        ignore: string;
+        invertSwap: boolean;
+        invertedSwapThreshold: number;
+        preventOnFilter: boolean;
+        removeCloneOnHide: boolean;
+        store: {
+            get: (sortable: import("sortablejs")) => string[];
+            set: (sortable: import("sortablejs")) => void;
+        };
+        swapThreshold: number;
+        touchStartThreshold: number;
+        setData: (dataTransfer: DataTransfer, draggedElement: HTMLElement) => void;
+        onStart: (event: import("sortablejs").SortableEvent) => void;
+        onAdd: (event: import("sortablejs").SortableEvent) => void;
+        onClone: (event: import("sortablejs").SortableEvent) => void;
+        onChoose: (event: import("sortablejs").SortableEvent) => void;
+        onUnchoose: (event: import("sortablejs").SortableEvent) => void;
+        onUpdate: (event: import("sortablejs").SortableEvent) => void;
+        onSort: (event: import("sortablejs").SortableEvent) => void;
+        onRemove: (event: import("sortablejs").SortableEvent) => void;
+        onFilter: (event: import("sortablejs").SortableEvent) => void;
+        onMove: (evt: import("sortablejs").MoveEvent, originalEvent: Event) => boolean | void | 1 | -1;
+        forceAutoScrollFallback: boolean;
+        scrollFn: (this: import("sortablejs"), offsetX: number, offsetY: number, originalEvent: Event, touchEvt: TouchEvent, hoverTargetEl: HTMLElement) => void | "continue";
+        scrollSensitivity: number;
+        scrollSpeed: number;
+        bubbleScroll: boolean;
+        multiDrag: boolean;
+        selectedClass: string;
+        multiDragKey: string;
+        avoidImplicitDeselect: boolean;
+        onDeselect: (event: import("sortablejs").SortableEvent) => void;
+        revertOnSpill: boolean;
+        removeOnSpill: boolean;
+        onSpill: (evt: import("sortablejs").SortableEvent) => void;
+        swap: boolean;
+        swapClass: string;
+        onAfterEnd: <T = any, R = any>(params: T) => R;
+    };
+}, {}>;
+export default _sfc_main;