vxe-gantt 3.9.0 → 3.9.2

package/es/gantt/src/gantt.d.ts

@@ -0,0 +1,729 @@
+import { VNode, CreateElement } from 'vue';
+import type { ValueOf, VxePagerDefines, VxeComponentStyleType, VxeComponentSizeType, VxeComponentIsVScrollbar, VxeFormDefines, VxeFormItemPropTypes, VxeScrollbarProps } from 'vxe-pc-ui';
+import type { VxeToolbarPropTypes, VxeTableDefines, VxeToolbarInstance, VxeTablePropTypes, VxeGridPropTypes } from 'vxe-table';
+import type { VxeGanttEmits, GanttReactData, GanttInternalData, VxeGanttPropTypes, VxeGanttDefines } from '../../../types';
+declare const _default: import("vue/types/vue").ExtendedVue<import("vue").default, {
+    xID: string;
+    reactData: GanttReactData<any>;
+    internalData: GanttInternalData;
+    reViewFlag: number;
+    scrollDefaultConf: VxeScrollbarProps;
+}, {
+    dispatchEvent(type: ValueOf<VxeGanttEmits>, params: Record<string, any>, evnt: Event | null): void;
+    handleTaskScaleConfig(): void;
+    initToolbar(): void;
+    initGanttView(): void;
+    initPages(propKey?: "currentPage" | "pageSize" | "total"): void;
+    triggerPendingEvent(code: string): void;
+    getRespMsg(rest: any, defaultMsg: string): any;
+    handleDeleteRow(code: string, alertKey: string, callback: () => void): Promise<void>;
+    pageChangeEvent(params: VxePagerDefines.PageChangeEventParams): void;
+    handleSortEvent(params: VxeTableDefines.SortChangeEventParams): void;
+    sortChangeEvent(params: VxeTableDefines.SortChangeEventParams): void;
+    clearAllSortEvent(params: VxeTableDefines.SortChangeEventParams): void;
+    handleFilterEvent(params: VxeTableDefines.ClearAllFilterEventParams): void;
+    filterChangeEvent(params: VxeTableDefines.ClearAllFilterEventParams): void;
+    clearAllFilterEvent(params: VxeTableDefines.ClearAllFilterEventParams): void;
+    submitFormEvent(params: VxeFormDefines.SubmitEventParams): void;
+    resetFormEvent(params: VxeFormDefines.ResetEventParams): void;
+    submitInvalidEvent(params: VxeFormDefines.SubmitInvalidEventParams): void;
+    collapseEvent(params: VxeFormDefines.CollapseEventParams): void;
+    handleZoom(isMax?: boolean): Promise<boolean>;
+    dragSplitEvent(evnt: MouseEvent): void;
+    handleSplitAnimat(): void;
+    handleSplitLeftViewEvent(): void;
+    handleSplitRightViewEvent(): void;
+    getDefaultFormData(): any;
+    initProxy(): void;
+    updateQueryFooter(): Promise<any> | undefined;
+    handleGlobalKeydownEvent(evnt: KeyboardEvent): void;
+    getEl(): HTMLDivElement;
+    /**
+     * 提交指令，支持 code 或 button
+     * @param {String/Object} code 字符串或对象
+     */
+    commitProxy(proxyTarget: string | VxeToolbarPropTypes.ButtonConfig, ...args: any[]): Promise<any>;
+    getParams(): any;
+    zoom(): Promise<boolean>;
+    isMaximized(): boolean;
+    maximize(): Promise<boolean>;
+    revert(): Promise<boolean>;
+    getFormData(): any;
+    /**
+     * 已废弃，被 getFormFlatItems 替换
+     * @deprecated
+     */
+    getFormItems(itemIndex?: number): any;
+    getFormFlatItems(): VxeFormDefines.ItemInfo[];
+    getFormNestedItems(): VxeFormDefines.ItemInfo[];
+    getFormItemByField(field: string): VxeFormDefines.ItemInfo | null;
+    resetForm(): Promise<any>;
+    validateForm(): Promise<void | VxeFormDefines.ValidateErrorMapParams>;
+    validateFormField(field: VxeFormItemPropTypes.Field | VxeFormItemPropTypes.Field[] | VxeFormDefines.ItemInfo | VxeFormDefines.ItemInfo[] | null): Promise<void | VxeFormDefines.ValidateErrorMapParams>;
+    clearFormValidate(field?: VxeFormItemPropTypes.Field | VxeFormItemPropTypes.Field[] | VxeFormDefines.ItemInfo | VxeFormDefines.ItemInfo[] | null): Promise<any>;
+    homePage(): Promise<void>;
+    homePageByEvent(evnt: Event): void;
+    endPage(): Promise<void>;
+    endPageByEvent(evnt: Event): void;
+    getCurrentPage(): number;
+    setCurrentPage(currentPage: number | string | null | undefined): Promise<void>;
+    setCurrentPageByEvent(evnt: Event, currentPage: number | string | null | undefined): void;
+    getPageSize(): number;
+    setPageSize(pageSize: number | string | null | undefined): Promise<void>;
+    setPageSizeByEvent(evnt: Event, pageSize: number | string | null | undefined): void;
+    getProxyInfo(): {
+        data: any[];
+        filter: VxeTableDefines.FilterCheckedParams<any>[];
+        form: any;
+        sort: {};
+        sorts: VxeTableDefines.SortCheckedParams<any>[];
+        pager: {
+            total: number;
+            pageSize: number;
+            currentPage: number;
+        };
+        pendingRecords: any[];
+    } | null;
+    getCustomPagerData(): {
+        pSize: number;
+    } | {
+        pSize?: undefined;
+    };
+    refreshTaskView(): Promise<void>;
+    hasTableViewVisible(): boolean;
+    showTableView(): Promise<void>;
+    hideTableView(): Promise<void>;
+    hasTaskViewVisible(): boolean;
+    showTaskView(): Promise<void>;
+    hideTaskView(): Promise<void>;
+    /**
+     * 关闭 bar tooltip
+     */
+    closeTaskBarTooltip(): Promise<void>;
+    callSlot(slotFunc: any, params: any, h: CreateElement): import("vxe-pc-ui").VxeComponentSlotType[];
+    scrollToDateView(colDate: string | number | Date): Promise<void>;
+    scrollToTaskView(rowOrRowid: any): Promise<void>;
+    getCriticalPath(): {
+        rowIds: string[];
+        rows: any[];
+        links: VxeGanttPropTypes.Link<any>[];
+    };
+    /**
+     * 获取需要排除的高度
+     */
+    getExcludeHeight(): number;
+    getParentElem(): HTMLElement | null;
+    getParentHeight(): number;
+    triggerToolbarCommitEvent(params: any, evnt: any): Promise<void> | undefined;
+    triggerToolbarBtnEvent(button: any, evnt: any): void;
+    triggerToolbarTolEvent(tool: any, evnt: any): void;
+    triggerZoomEvent(evnt: Event): void;
+    handleTaskCellClickEvent(evnt: MouseEvent, params: VxeGanttDefines.TaskCellClickParams): void;
+    handleTaskCellDblclickEvent(evnt: MouseEvent, params: VxeGanttDefines.TaskCellClickParams): void;
+    handleTaskBarClickEvent(evnt: MouseEvent, params: VxeGanttDefines.TaskCellClickParams): void;
+    handleTaskBarDblclickEvent(evnt: MouseEvent, params: VxeGanttDefines.TaskCellClickParams): void;
+    triggerTaskBarTooltipEvent(evnt: MouseEvent, params: VxeGanttDefines.TaskBarMouseoverParams): void;
+    handleTargetEnterEvent(isClear: boolean): void;
+    handleTaskBarTooltipLeaveEvent(): void;
+    handleTableLinks(): void;
+    handleTaskHeaderContextmenuEvent(evnt: Event, params: VxeGanttDefines.TaskHeaderContextmenuParams): void;
+    handleTaskBodyContextmenuEvent(evnt: Event, params: VxeGanttDefines.TaskBodyContextmenuParams): void;
+    handleTaskFooterContextmenuEvent(evnt: Event, params: VxeGanttDefines.TaskFooterContextmenuParams): void;
+    handleTaskBarContextmenuEvent(evnt: Event, params: VxeGanttDefines.TaskBarContextmenuParams): void;
+    loadColumn(columns: any[]): Promise<any>;
+    reloadColumn(columns: any[]): Promise<any>;
+    getConfigSlot(slotConfigs?: Record<string, any>): Record<string, any>;
+    getToolbarSlots(): {
+        buttons?(params: any): any;
+        buttonPrefix?(params: any): any;
+        buttonSuffix?(params: any): any;
+        tools?(params: any): any;
+        toolPrefix?(params: any): any;
+        toolSuffix?(params: any): any;
+    };
+    getFuncSlot(optSlots: any, slotKey: any): any;
+    renderDefaultForm(h: CreateElement): VNode[];
+    renderForm(h: CreateElement): VNode;
+    renderToolbar(h: CreateElement): VNode;
+    renderTop(h: CreateElement): VNode;
+    renderTableLeft(h: CreateElement): VNode;
+    renderTableRight(h: CreateElement): VNode;
+    renderTable(h: CreateElement): VNode;
+    renderBottom(h: CreateElement): VNode;
+    renderPager(h: CreateElement): VNode;
+    /**
+     * 渲染任务视图
+     */
+    renderTaskView(h: CreateElement): VNode;
+    renderSplitBar(h: CreateElement): VNode;
+    renderChildLayout(h: CreateElement, layoutKeys: VxeGanttDefines.LayoutKey[]): VNode[];
+    renderLayout(h: CreateElement): VNode[];
+    renderVN(h: CreateElement): VNode;
+    getScrollViewElem(): HTMLElement | null | undefined;
+    clearAll(): Promise<void>;
+    syncData(): Promise<void>;
+    updateData(): Promise<void>;
+    loadData(data: any[]): Promise<any>;
+    reloadData(data: any[]): Promise<void>;
+    setRow(rows: any | any[], record?: any): Promise<void>;
+    reloadRow(rows: any | any[], record?: any, field?: string): Promise<void>;
+    loadTreeChildren(row: any, children: any[]): Promise<any[]>;
+    getRowNode(trElem: HTMLElement): {
+        rowid: string;
+        item: any;
+        items: any[];
+        index: number;
+        parent?: any;
+    } | null;
+    getColumnNode(cellElem: HTMLElement): {
+        colid: string;
+        item: VxeTableDefines.ColumnInfo;
+        items: VxeTableDefines.ColumnInfo[];
+        index: number;
+        parent?: VxeTableDefines.ColumnInfo | null;
+    } | null;
+    getRowSeq(row: any): string | number;
+    getRowIndex(row: any): number;
+    getVTRowIndex(row: any): number;
+    getVMRowIndex(row: any): number;
+    getColumnIndex(column: VxeTableDefines.ColumnInfo | null): number;
+    getVTColumnIndex(column: VxeTableDefines.ColumnInfo | null): number;
+    getVMColumnIndex(column: VxeTableDefines.ColumnInfo | null): number;
+    createData(records: any[]): Promise<any[]>;
+    createRow(records: any | any[]): Promise<any | any[]>;
+    revertData(rows?: any | any[], field?: string): Promise<any>;
+    clearData(rows?: any | any[], field?: string): Promise<any>;
+    effectCellData(row: any, column: VxeTableDefines.ColumnInfo, options: VxeTableDefines.CellCacheHandleOptions): VxeTableDefines.CellCacheResultObj;
+    getCellElement(row: any, fieldOrColumn: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | null): HTMLElement | null;
+    getCellLabel(row: any, fieldOrColumn: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | null): string | number | null;
+    updateCellLabel(row: any, fieldOrColumn: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | null): string | number | null;
+    clearFormatterCache(isUpdate?: boolean): Promise<void>;
+    getHeaderCellLabel(fieldOrColumn: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | null): string;
+    updateHeaderCellLabel(fieldOrColumn: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | null): string;
+    clearHeaderFormatterCache(isUpdate?: boolean): Promise<void>;
+    getFooterCellLabel(row: any, fieldOrColumn: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | null): string | number | null;
+    updateFooterCellLabel(row: any, fieldOrColumn: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | null): string | number | null;
+    clearFooterFormatterCache(isUpdate?: boolean): Promise<void>;
+    isInsertByRow(row: any | null): boolean;
+    isRemoveByRow(row: any | null): boolean;
+    removeInsertRow(): Promise<{
+        row: any;
+        rows: any[];
+    }>;
+    isUpdateByRow(row: any, field?: string | null): boolean;
+    getUpdateCells(): VxeTableDefines.UpdateCellObj<any>[];
+    getColumns(): VxeTableDefines.ColumnInfo[];
+    getColumns(columnIndex?: number): VxeTableDefines.ColumnInfo;
+    getColid(fieldOrColumn: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | null): string | null;
+    getColumnById(colid: string | null): VxeTableDefines.ColumnInfo | null;
+    getColumnByField(field: import("vxe-table").VxeColumnPropTypes.Field | null): VxeTableDefines.ColumnInfo | null;
+    getParentColumn(fieldOrColumn: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | null): VxeTableDefines.ColumnInfo | null;
+    getTableColumn(): {
+        collectColumn: VxeTableDefines.ColumnInfo[];
+        fullColumn: VxeTableDefines.ColumnInfo[];
+        visibleColumn: VxeTableDefines.ColumnInfo[];
+        tableColumn: VxeTableDefines.ColumnInfo[];
+    };
+    moveColumnTo(fieldOrColumn: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo, targetFieldOrColumn: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | number, options?: {
+        isCrossDrag?: boolean;
+        dragToChild?: boolean;
+        dragPos?: "left" | "right" | "" | null;
+    }): Promise<{
+        status: boolean;
+    }>;
+    moveRowTo(rowidOrRow: any, targetRowidOrRow: any, options?: {
+        isCrossDrag?: boolean;
+        dragToChild?: boolean;
+        dragPos?: "top" | "bottom" | "" | null;
+    }): Promise<{
+        status: boolean;
+    }>;
+    getFullColumns(): VxeTableDefines.ColumnInfo[];
+    getData(): any[];
+    getData(rowIndex: number): any;
+    getCheckboxRecords(isFull?: boolean): any[];
+    getTreeRowChildren(rowOrRowid: any): any[];
+    getTreeRowLevel(rowOrRowid: any): any;
+    getTreeParentRow(rowOrRowid: any): number;
+    getParentRow(rowOrRowid: any): any;
+    getRowById(rowid: string | number | null): any;
+    getRowid(row: any | null): string;
+    getTableData(): {
+        fullData: any[];
+        visibleData: any[];
+        tableData: any[];
+        footerData: any[];
+    };
+    getFullData(): any[];
+    setColumnFixed(fieldOrColumns: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | import("vxe-table").VxeColumnPropTypes.Field[] | VxeTableDefines.ColumnInfo[], fixed: import("vxe-table").VxeColumnPropTypes.Fixed): Promise<void>;
+    clearColumnFixed(fieldOrColumns: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | import("vxe-table").VxeColumnPropTypes.Field[] | VxeTableDefines.ColumnInfo[]): Promise<void>;
+    hideColumn(fieldOrColumns: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | import("vxe-table").VxeColumnPropTypes.Field[] | VxeTableDefines.ColumnInfo[]): Promise<void>;
+    showColumn(fieldOrColumn: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | import("vxe-table").VxeColumnPropTypes.Field[] | VxeTableDefines.ColumnInfo[]): Promise<void>;
+    setColumnWidth(fieldOrColumns: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | import("vxe-table").VxeColumnPropTypes.Field[] | VxeTableDefines.ColumnInfo[], width: number | string): Promise<{
+        status: boolean;
+    }>;
+    getColumnWidth(fieldOrColumn: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo): number;
+    resetColumn(options?: boolean | {
+        visible?: boolean;
+        resizable?: boolean;
+        fixed?: boolean;
+        order?: boolean;
+    }): Promise<void>;
+    refreshColumn(resiveOrder?: boolean): Promise<void>;
+    setRowHeightConf(heightConf: Record<string, number>): Promise<{
+        status: boolean;
+    }>;
+    getRowHeightConf(isFull?: boolean): Record<string, number>;
+    setRowHeight(rowOrId: any | any[], height: number | string): Promise<{
+        status: boolean;
+    }>;
+    recalcRowHeight(rowOrId: any | any[]): Promise<{
+        status: boolean;
+    }>;
+    getRowHeight(rowOrId: any): number;
+    refreshScroll(): Promise<void>;
+    recalculate(refull?: boolean): Promise<void>;
+    openTooltip(target: HTMLElement, content: string | number): Promise<any>;
+    closeTooltip(): Promise<any>;
+    setCheckboxRow(rows: any | any[], checked: boolean): Promise<any>;
+    setCheckboxRowKey(keys: string | number | (string | number)[] | null | undefined, checked: boolean): Promise<any>;
+    setCheckboxRowByKey(keys: string | number | (string | number)[] | null | undefined, checked: boolean): Promise<any>;
+    isAllCheckboxChecked(): boolean;
+    isAllCheckboxIndeterminate(): boolean;
+    isCheckedByCheckboxRow(row: any): boolean;
+    isCheckedByCheckboxRowKey(key: string | number | null | undefined): boolean;
+    isIndeterminateByCheckboxRow(row: any): boolean;
+    isIndeterminateByCheckboxRowKey(key: string | number | null | undefined): boolean;
+    toggleCheckboxRow(row: any): Promise<any>;
+    setAllCheckboxRow(checked: boolean): Promise<any>;
+    getRadioReserveRecord(isFull?: boolean): any;
+    clearRadioReserve(): Promise<any>;
+    getCheckboxReserveRecords(isFull?: boolean): any[];
+    getCheckboxIndeterminateRecords(isFull?: boolean): any[];
+    clearCheckboxReserve(): Promise<any>;
+    toggleAllCheckboxRow(): Promise<any>;
+    clearCheckboxRow(): Promise<any>;
+    setCurrentRow(row: any): Promise<any>;
+    isCheckedByRadioRow(row: any | null): boolean;
+    isCheckedByRadioRowKey(key: string | number | null | undefined): boolean;
+    setRadioRow(row: any): Promise<any>;
+    setRadioRowKey(key: string | number | null | undefined): Promise<any>;
+    setRadioByRowKey(key: string | number | null | undefined): Promise<any>;
+    setPendingRow(rows: any | any[], status: boolean): Promise<any>;
+    togglePendingRow(rows: any | any[]): Promise<any>;
+    getPendingRecords(): any[];
+    hasPendingByRow(row: any): boolean;
+    isPendingByRow(row: any): boolean;
+    clearPendingRow(): Promise<any>;
+    clearMergeCells(): Promise<any>;
+    clearMergeHeaderCells(): Promise<any>;
+    clearMergeFooterCells(): Promise<any>;
+    clearMergeFooterItems(): Promise<any>;
+    clearCurrentRow(): Promise<any>;
+    clearRadioRow(): Promise<any>;
+    getMergeCells(): VxeTableDefines.MergeInfo[];
+    getMergeHeaderCells(): VxeTableDefines.MergeInfo[];
+    getMergeFooterCells(): VxeTableDefines.MergeInfo[];
+    getMergeFooterItems(): VxeTableDefines.MergeInfo[];
+    getCurrentColumn(): VxeTableDefines.ColumnInfo | null;
+    getCurrentRecord(isFull?: boolean): any;
+    getRadioRecord(isFull?: boolean): any;
+    setCurrentColumn(fieldOrColumn: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo): Promise<void>;
+    clearCurrentColumn(): Promise<void>;
+    sort(field: string, order?: VxeTablePropTypes.SortOrder): Promise<void>;
+    sort(sortConfs: VxeTableDefines.SortConfs, order?: VxeTablePropTypes.SortOrder): Promise<void>;
+    sort(sortConfs: VxeTableDefines.SortConfs[], order?: VxeTablePropTypes.SortOrder): Promise<void>;
+    setSort(sortConfs: VxeTableDefines.SortConfs | VxeTableDefines.SortConfs[], update?: boolean): Promise<void>;
+    setSortByEvent(event: Event, sortConfs: VxeTableDefines.SortConfs | VxeTableDefines.SortConfs[]): Promise<void>;
+    clearSort(fieldOrColumn?: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | null): Promise<void>;
+    clearSortByEvent(event: Event, fieldOrColumn?: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | null): Promise<void>;
+    isSort(fieldOrColumn: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo): boolean;
+    getSortColumns(): VxeTableDefines.SortCheckedParams[];
+    closeFilter(): Promise<any>;
+    isFilter(fieldOrColumn: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | null): boolean;
+    setFilterByEvent(event: Event, fieldOrColumn: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo, options: import("vxe-table").VxeColumnPropTypes.Filters): Promise<void>;
+    clearFilterByEvent(event: Event, fieldOrColumn?: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | null): Promise<void>;
+    isActiveFilterByColumn(fieldOrColumn: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | null): boolean;
+    isRowExpandLoaded(row: any | null): boolean;
+    clearRowExpandLoaded(row: any): Promise<void>;
+    reloadRowExpand(row: any): Promise<void>;
+    reloadExpandContent(row: any): Promise<void>;
+    toggleRowExpand(row: any): Promise<void>;
+    setAllRowExpand(checked: boolean): Promise<void>;
+    setRowExpand(rows: any | any[], expanded: boolean): Promise<void>;
+    isRowExpandByRow(row: any | null): boolean;
+    isExpandByRow(row: any | null): boolean;
+    clearRowExpand(): Promise<void>;
+    clearRowExpandReserve(): Promise<void>;
+    getRowExpandRecords(): any[];
+    setRowGroups(fieldOrColumns: (import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo)[] | import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | null): Promise<void>;
+    getRowGroups(): ({
+        field: import("vxe-table").VxeColumnPropTypes.Field;
+    } | VxeTableDefines.ColumnInfo)[];
+    getRowGroupFields(): import("vxe-table").VxeColumnPropTypes.Field[];
+    clearRowGroups(): Promise<void>;
+    setRowGroupExpand(rows: any | any[], expanded: boolean): Promise<void>;
+    setRowGroupExpandByField(groupFields: string | string[], expanded: boolean): Promise<void>;
+    setAllRowGroupExpand(expanded: boolean): Promise<void>;
+    clearRowGroupExpand(): Promise<void>;
+    isRowGroupExpandByRow(row: any): boolean;
+    isRowGroupRecord(row: any): boolean;
+    isAggregateExpandByRow(row: any): boolean;
+    isAggregateRecord(row: any): boolean;
+    getAggregateContentByRow(row: any): string;
+    getAggregateRowChildren(row: any): any[];
+    refreshAggregateCalcValues(): Promise<void>;
+    getTreeExpandRecords(): any[];
+    isTreeExpandLoaded(row: any | null): boolean;
+    clearTreeExpandLoaded(row: any | any[]): Promise<any>;
+    reloadTreeExpand(row: any, autoExpand?: boolean): Promise<any>;
+    reloadTreeChilds(row: any): Promise<any>;
+    toggleTreeExpand(row: any): Promise<any>;
+    setAllTreeExpand(checked: boolean): Promise<void>;
+    setTreeExpand(rows: any | any[], checked: boolean): Promise<void>;
+    isTreeExpandByRow(row: any | null): boolean;
+    clearTreeExpand(): Promise<void>;
+    clearTreeExpandReserve(): Promise<void>;
+    getScroll(): {
+        virtualX: boolean;
+        virtualY: boolean;
+        scrollTop: number;
+        scrollLeft: number;
+    };
+    getScrollData(): {
+        virtualX: boolean;
+        virtualY: boolean;
+        isTop: boolean;
+        isBottom: boolean;
+        isLeft: boolean;
+        isRight: boolean;
+        scrollbarHeight: number;
+        scrollbarWidth: number;
+        scrollTop: number;
+        scrollLeft: number;
+        scrollHeight: number;
+        scrollWidth: number;
+        clientHeight: number;
+        clientWidth: number;
+    };
+    scrollTo(x: {
+        top?: number | null;
+        left?: number | null;
+    } | number | null | undefined, y?: number | null): Promise<void>;
+    scrollToRow(rowOrRowid: any, fieldOrColumn?: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | null, options?: VxeTableDefines.ScrollToColumnConfig): Promise<any>;
+    scrollToStartRow(fieldOrColumn?: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | null, options?: VxeTableDefines.ScrollToColumnConfig): Promise<any>;
+    scrollToEndRow(fieldOrColumn?: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | null, options?: VxeTableDefines.ScrollToColumnConfig): Promise<any>;
+    scrollToColumn(fieldOrColumn: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo, options?: VxeTableDefines.ScrollToColumnConfig): Promise<any>;
+    scrollToStartColumn(options?: VxeTableDefines.ScrollToColumnConfig): Promise<any>;
+    scrollToEndColumn(options?: VxeTableDefines.ScrollToColumnConfig): Promise<any>;
+    clearScroll(): Promise<any>;
+    updateFooter(): Promise<any>;
+    updateStatus(params: {
+        row: any;
+        column: VxeTableDefines.ColumnInfo;
+    }, cellValue?: any): Promise<any>;
+    removeMergeCells(merges: VxeTableDefines.MergeOptions<any> | VxeTableDefines.MergeOptions<any>[]): Promise<VxeTableDefines.MergeInfo[]>;
+    removeMergeHeaderCells(merges: VxeTableDefines.MergeOptions<any> | VxeTableDefines.MergeOptions<any>[]): Promise<VxeTableDefines.MergeInfo[]>;
+    removeMergeFooterCells(merges: VxeTableDefines.MergeOptions<any> | VxeTableDefines.MergeOptions<any>[]): Promise<VxeTableDefines.MergeInfo[]>;
+    removeMergeFooterItems(merges: VxeTableDefines.MergeOptions<any> | VxeTableDefines.MergeOptions<any>[]): Promise<VxeTableDefines.MergeInfo[]>;
+    setMergeCells(merges: VxeTableDefines.MergeOptions<any> | VxeTableDefines.MergeOptions<any>[]): Promise<any>;
+    setMergeHeaderCells(merges: VxeTableDefines.MergeOptions<any> | VxeTableDefines.MergeOptions<any>[]): Promise<any>;
+    setMergeFooterCells(merges: VxeTableDefines.MergeOptions<any> | VxeTableDefines.MergeOptions<any>[]): Promise<any>;
+    setMergeFooterItems(merges: VxeTableDefines.MergeOptions<any> | VxeTableDefines.MergeOptions<any>[]): Promise<any>;
+    updateCellAreas(): Promise<void>;
+    undo(): Promise<{
+        status: boolean;
+    }>;
+    redo(): Promise<{
+        status: boolean;
+    }>;
+    clearHistory(): Promise<void>;
+    connect(toolbar: import("vxe-table").VxeToolbarConstructor | VxeToolbarInstance): Promise<void>;
+    connectToolbar(toolbar: import("vxe-table").VxeToolbarConstructor | VxeToolbarInstance): Promise<void>;
+    focus(): Promise<void>;
+    blur(): Promise<void>;
+    setCustomStoreData(storeData: VxeTableDefines.CustomStoreData | null): Promise<void>;
+    getCustomStoreData(): VxeTableDefines.CustomStoreData;
+    updateThumbSize(): void;
+    updateThumbOffset(): void;
+    clickTrackXEvent(evnt: MouseEvent): void;
+    clickTrackYEvent(evnt: MouseEvent): void;
+    pointerdownThumbXEvent(evnt: PointerEvent): void;
+    pointermoveThumbXEvent(evnt: PointerEvent): void;
+    cleatPointerThumbEvent(evnt: PointerEvent): void;
+    pointerdownThumbYEvent(evnt: PointerEvent): void;
+    pointermoveThumbYEvent(evnt: PointerEvent): void;
+    getCellAreas(): import("vxe-table").VxeTableExtendCellAreaDefines.MouseCellArea[];
+    getActiveCellArea(): import("vxe-table").VxeTableExtendCellAreaDefines.MouseActiveCellArea | null;
+    getCopyCellArea(): import("vxe-table").VxeTableExtendCellAreaDefines.MouseCellArea | null;
+    getCopyCellAreas(): import("vxe-table").VxeTableExtendCellAreaDefines.MouseCellArea[];
+    copyCellArea(): {
+        text: string;
+        html: string;
+    };
+    cutCellArea(): {
+        text: string;
+        html: string;
+    };
+    pasteCellArea(): Promise<any>;
+    clearCellAreas(area?: number | import("vxe-table").VxeTableExtendCellAreaDefines.MouseCellArea): Promise<any>;
+    clearCopyCellArea(): Promise<any>;
+    setCellAreas(areaConfigs: import("vxe-table").VxeTableExtendCellAreaDefines.CellAreaConfig[], activeArea?: {
+        area?: number | import("vxe-table").VxeTableExtendCellAreaDefines.CellAreaConfig<any> | undefined;
+        column?: number | VxeTableDefines.ColumnInfo;
+        row?: any;
+    } | undefined): Promise<any>;
+    setActiveCellArea(activeArea: import("vxe-table").VxeTableExtendCellAreaDefines.ActiveCellAreaConfig): Promise<any>;
+    openFind(): Promise<any>;
+    openReplace(): Promise<any>;
+    openFNR(options: {
+        type?: "find" | "replace" | "" | null;
+    }): Promise<any>;
+    closeFNR(): Promise<any>;
+    openFilter(fieldOrColumn: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo): Promise<void>;
+    setFilter(fieldOrColumn: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo, options: import("vxe-table").VxeColumnPropTypes.Filters, update?: boolean): Promise<void>;
+    clearFilter(column?: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | null): Promise<void>;
+    saveFilterPanel(): Promise<any>;
+    saveFilterPanelByEvent(event: Event): Promise<any>;
+    resetFilterPanel(): Promise<any>;
+    resetFilterPanelByEvent(event: Event): Promise<any>;
+    saveFilter(fieldOrColumn?: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | null): Promise<any>;
+    saveFilterByEvent(event: Event, fieldOrColumn: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | null): Promise<any>;
+    resetFilter(fieldOrColumn?: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | null): Promise<any>;
+    resetFilterByEvent(event: Event, fieldOrColumn: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | null): Promise<any>;
+    getCheckedFilters(): VxeTableDefines.FilterCheckedParams<any>[];
+    updateFilterOptionStatus(item: VxeTableDefines.FilterOption | import("vxe-table").VxeColumnPropTypes.FilterItem, checked: boolean): Promise<void>;
+    closeMenu(): Promise<any>;
+    insert(records: any): Promise<{
+        row: any;
+        rows: any[];
+    }>;
+    insertAt(records: any, targetRowOrRowid?: any | -1 | null): Promise<{
+        row: any;
+        rows: any[];
+    }>;
+    insertNextAt(records: any, targetRowOrRowid?: any | -1 | null): Promise<{
+        row: any;
+        rows: any[];
+    }>;
+    insertChild(records: any, parentRowOrParentId: any): Promise<{
+        row: any;
+        rows: any[];
+    }>;
+    insertChildAt(records: any, parentRowOrParentId: any, targetRowOrRowid: any | -1 | null): Promise<{
+        row: any;
+        rows: any[];
+    }>;
+    insertChildNextAt(records: any, parentRowOrParentId: any, targetRowOrRowid: any | -1 | null): Promise<{
+        row: any;
+        rows: any[];
+    }>;
+    remove(rows?: any | any[]): Promise<{
+        row: any;
+        rows: any[];
+    }>;
+    removeCheckboxRow(): Promise<{
+        row: any;
+        rows: any[];
+    }>;
+    removeRadioRow(): Promise<{
+        row: any;
+        rows: any[];
+    }>;
+    removeCurrentRow(): Promise<{
+        row: any;
+        rows: any[];
+    }>;
+    getRecordset(): {
+        insertRecords: any[];
+        removeRecords: any[];
+        updateRecords: any[];
+        pendingRecords: any[];
+    };
+    getInsertRecords(): any[];
+    getRemoveRecords(): any[];
+    getUpdateRecords(): any[];
+    getActiveRecord(): {
+        row: any;
+        column: VxeTableDefines.ColumnInfo;
+        rowIndex: number;
+        $rowIndex: number;
+        columnIndex: number;
+        $columnIndex: number;
+        cell: HTMLElement;
+    };
+    getEditRecord(): {
+        row: any;
+        column: VxeTableDefines.ColumnInfo;
+        rowIndex: number;
+        $rowIndex: number;
+        columnIndex: number;
+        $columnIndex: number;
+        cell: HTMLElement;
+    };
+    getEditCell(): {
+        row: any;
+        column: VxeTableDefines.ColumnInfo;
+    } | null;
+    getSelectedCell(): {
+        row: any;
+        column: VxeTableDefines.ColumnInfo;
+    };
+    clearActived(row?: any): Promise<any>;
+    clearEdit(row?: any): Promise<any>;
+    clearSelected(): Promise<any>;
+    isActiveByRow(row: any): boolean;
+    isEditByRow(row: any): boolean;
+    setActiveRow(row: any): Promise<void>;
+    setEditRow(row: any, fieldOrColumn?: boolean | string | VxeTableDefines.ColumnInfo | null, options?: {
+        isClear?: boolean;
+    }): Promise<void>;
+    setActiveCell(row: any, fieldOrColumn: string | VxeTableDefines.ColumnInfo): Promise<void>;
+    setEditCell(row: any, fieldOrColumn: string | VxeTableDefines.ColumnInfo | null, options?: {
+        isClear?: boolean;
+    }): Promise<void>;
+    setSelectCell(row: any, fieldOrColumn: string | VxeTableDefines.ColumnInfo): Promise<void>;
+    openExport(options?: VxeTablePropTypes.ExportConfig): void;
+    closeExport(): Promise<any>;
+    exportData(options?: VxeTablePropTypes.ExportConfig): Promise<any>;
+    openImport(options?: VxeTablePropTypes.ImportConfig): void;
+    closeImport(): Promise<any>;
+    importData(options?: VxeTablePropTypes.ImportConfig): Promise<any>;
+    importByFile(file: File, options: VxeTablePropTypes.ImportConfig): Promise<any>;
+    saveFile: import("vxe-table").SaveFileFunction;
+    readFile: import("vxe-table").ReadFileFunction;
+    print: import("vxe-table").PrintFunction;
+    getPrintHtml(options?: VxeTablePropTypes.PrintConfig): Promise<{
+        html: string;
+    }>;
+    openPrint(options?: VxeTablePropTypes.PrintConfig): void;
+    closePrint(): Promise<any>;
+    clearValidate(rows?: any, fieldOrColumn?: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | import("vxe-table").VxeColumnPropTypes.Field[] | VxeTableDefines.ColumnInfo[]): Promise<void>;
+    fullValidate(rows?: boolean | object | any[] | ((errMap: VxeTableDefines.ValidatorErrorMapParams<any>) => void) | undefined, callback?: ((errMap: VxeTableDefines.ValidatorErrorMapParams<any>) => void) | undefined): Promise<VxeTableDefines.ValidatorErrorMapParams<any>>;
+    validate(rows?: boolean | object | any[] | ((errMap?: VxeTableDefines.ValidatorErrorMapParams<any> | undefined) => void) | undefined, callback?: ((errMap?: VxeTableDefines.ValidatorErrorMapParams<any> | undefined) => void) | undefined): Promise<VxeTableDefines.ValidatorErrorMapParams<any>>;
+    fullValidateField(rows?: boolean | object | any[], fieldOrColumn?: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | import("vxe-table").VxeColumnPropTypes.Field[] | VxeTableDefines.ColumnInfo[]): Promise<VxeTableDefines.ValidatorErrorMapParams<any>>;
+    validateField(rows?: boolean | object | any[], fieldOrColumn?: import("vxe-table").VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | import("vxe-table").VxeColumnPropTypes.Field[] | VxeTableDefines.ColumnInfo[]): Promise<VxeTableDefines.ValidatorErrorMapParams<any>>;
+    getCustomVisible(): boolean;
+    openCustom(): Promise<void>;
+    closeCustom(): Promise<void>;
+    toggleCustom(): Promise<void>;
+    resetCustom(options?: boolean | {
+        visible?: boolean;
+        resizable?: boolean;
+        fixed?: boolean;
+        order?: boolean;
+    }): Promise<void>;
+    saveCustom(isDirectly?: boolean): Promise<void>;
+    cancelCustom(): Promise<void>;
+    toggleCustomAllCheckbox(): Promise<void>;
+    setCustomAllCheckbox(checked: boolean): Promise<void>;
+}, {
+    computeProxyOpts: VxeGridPropTypes.ProxyConfig<any>;
+    computeIsRespMsg: boolean;
+    computeIsActiveMsg: boolean;
+    computePagerOpts: VxeGridPropTypes.PagerConfig;
+    computeFormOpts: VxeGridPropTypes.FormConfig;
+    computeToolbarOpts: VxeGridPropTypes.ToolbarConfig;
+    computeZoomOpts: VxeGridPropTypes.ZoomConfig;
+    computeTaskOpts: VxeGanttPropTypes.TaskConfig;
+    computeTaskViewScaleOpts: VxeGanttPropTypes.TaskViewScaleConfig;
+    computeTaskNowLineOpts: VxeGanttPropTypes.TaskNowLineConfig;
+    computeTaskViewOpts: VxeGanttPropTypes.TaskViewConfig<any>;
+    computeTaskBarOpts: VxeGanttPropTypes.TaskBarConfig<any>;
+    computeTaskBarMoveOpts: VxeGanttPropTypes.TaskBarMoveConfig<any>;
+    computeTaskBarMoveTooltipOpts: VxeGanttPropTypes.TaskBarMoveTooltipConfig<any>;
+    computeTaskBarResizeOpts: VxeGanttPropTypes.TaskBarResizeConfig<any>;
+    computeTaskBarResizeTooltipOpts: VxeGanttPropTypes.TaskBarResizeTooltipConfig<any>;
+    computeTaskSplitOpts: VxeGanttPropTypes.TaskSplitConfig;
+    computeTaskBarMilestoneOpts: VxeGanttPropTypes.TaskBarMilestoneConfig<any>;
+    computeTaskCriticalPathOpts: VxeGanttPropTypes.TaskCriticalPathConfig;
+    computeTaskBarSubviewOpts: VxeGanttPropTypes.TaskBarSubviewConfig<any>;
+    computeTaskBarTooltipOpts: VxeGanttPropTypes.TaskBarTooltipConfig<any>;
+    computeTaskLinkOpts: VxeGanttPropTypes.TaskLinkConfig<any>;
+    computeScaleUnit: VxeGanttDefines.ColumnScaleType;
+    computeDateFormat: string;
+    computeMinScale: VxeGanttDefines.ColumnScaleObj;
+    computeScaleStep: number;
+    computeWeekScale: VxeGanttDefines.ColumnScaleObj | undefined;
+    computeTaskViewScales: VxeGanttDefines.ColumnScaleType[] | VxeGanttDefines.ColumnScaleConfig[] | undefined;
+    computeTaskLinkStyle: string;
+    computeTaskScaleConfs: unknown;
+    computeTitleField: string;
+    computeStartField: string;
+    computeEndField: string;
+    computeTypeField: string;
+    computeProgressField: string;
+    computeScrollbarOpts: VxeTablePropTypes.ScrollbarConfig;
+    computeScrollbarXOpts: VxeTablePropTypes.ScrollbarXConfig;
+    computeScrollbarYOpts: VxeTablePropTypes.ScrollbarYConfig;
+    computeScrollXHeight: number;
+    computeScrollYWidth: number;
+    computeScrollXAutoHide: boolean | undefined;
+    computeScrollYAutoHide: boolean | undefined;
+    computeScrollbarXToTop: boolean;
+    computeScrollbarYToLeft: boolean;
+    computeCriticalPathVisible: boolean | undefined;
+    computeWrapperStyle: VxeComponentStyleType;
+    computeTableExtendProps: any;
+    computeTableProps: any;
+    tableProps: unknown;
+    computeCurrLayoutConf: {
+        headKeys: VxeGanttDefines.LayoutKey[];
+        bodyKeys: VxeGanttDefines.LayoutKey[];
+        footKeys: VxeGanttDefines.LayoutKey[];
+    };
+    computeCustomCurrentPageFlag: number | undefined;
+    computeCustomPageSizeFlag: number | undefined;
+    computeCustomTotalFlag: number | undefined;
+    computePageCount: number;
+    computeIsLoading: any;
+    computeTableBorder: "none" | "default" | "full" | "outer" | "inner";
+    computeSize: VxeComponentSizeType;
+    computeIsVScrollbar: VxeComponentIsVScrollbar;
+}, {
+    columns: VxeGridPropTypes.Columns<any>;
+    pagerConfig: VxeGridPropTypes.PagerConfig;
+    proxyConfig: VxeGridPropTypes.ProxyConfig<any>;
+    toolbarConfig: VxeGridPropTypes.ToolbarConfig;
+    formConfig: VxeGridPropTypes.FormConfig;
+    zoomConfig: VxeGridPropTypes.ZoomConfig;
+    links: VxeGanttPropTypes.Links<any>;
+    layouts: VxeGanttPropTypes.Layouts;
+    taskConfig: VxeGanttPropTypes.TaskConfig;
+    taskViewScaleConfig: VxeGanttPropTypes.TaskViewScaleConfig;
+    taskNowLineConfig: VxeGanttPropTypes.TaskNowLineConfig;
+    taskViewConfig: VxeGanttPropTypes.TaskViewConfig<any>;
+    taskLinkConfig: VxeGanttPropTypes.TaskLinkConfig<any>;
+    taskBarConfig: VxeGanttPropTypes.TaskBarConfig<any>;
+    taskBarMilestoneConfig: VxeGanttPropTypes.TaskBarMilestoneConfig<any>;
+    taskCriticalPathConfig: VxeGanttPropTypes.TaskCriticalPathConfig;
+    taskBarSubviewConfig: VxeGanttPropTypes.TaskBarSubviewConfig<any>;
+    taskBarTooltipConfig: VxeGanttPropTypes.TaskBarTooltipConfig<any>;
+    taskSplitConfig: VxeGanttPropTypes.TaskSplitConfig;
+    taskBarResizeConfig: VxeGanttPropTypes.TaskBarResizeConfig<any>;
+    taskBarResizeTooltipConfig: VxeGanttPropTypes.TaskBarResizeTooltipConfig<any>;
+    taskBarMoveConfig: VxeGanttPropTypes.TaskBarMoveConfig<any>;
+    taskBarMoveTooltipConfig: VxeGanttPropTypes.TaskBarMoveTooltipConfig<any>;
+    size: VxeComponentSizeType;
+    border: VxeTablePropTypes.Border;
+    round: boolean;
+    loading: boolean;
+    height: VxeTablePropTypes.Height;
+    minHeight: VxeTablePropTypes.MinHeight;
+    maxHeight: VxeTablePropTypes.MaxHeight;
+    seqConfig: VxeTablePropTypes.SeqConfig<VxeTablePropTypes.Row>;
+    editConfig: VxeTablePropTypes.EditConfig<any>;
+    sortConfig: VxeTablePropTypes.SortConfig<VxeTablePropTypes.Row>;
+    treeConfig: VxeTablePropTypes.TreeConfig<any>;
+    filterConfig: VxeTablePropTypes.FilterConfig<VxeTablePropTypes.Row>;
+    expandConfig: VxeTablePropTypes.ExpandConfig<any>;
+    aggregateConfig: VxeTablePropTypes.AggregateConfig<any>;
+    validConfig: VxeTablePropTypes.ValidConfig<any>;
+    editRules: VxeTablePropTypes.EditRules<any>;
+    animat: boolean;
+    useScrollbar: VxeComponentIsVScrollbar;
+    scrollbarConfig: VxeTablePropTypes.ScrollbarConfig;
+    showFooter: boolean;
+    params: any;
+}>;
+export default _default;