@fangzhongya/fang-ui 0.0.29 → 0.0.30

package/dist/components/tabless/src/index.d.ts

@@ -0,0 +1,3540 @@
+import { ComponentInternalInstance, Component, VNodeProps, AllowedComponentProps, ComponentCustomProps, CreateComponentPublicInstanceWithMixins, ExtractPropTypes, PropType, CSSProperties, ComputedRef, Ref, ComponentOptionsMixin, GlobalComponents, GlobalDirectives, ComponentProvideOptions, Slot, ComponentPublicInstance, ComponentOptionsBase, DebuggerEvent, nextTick, WatchOptions, WatchStopHandle, ShallowUnwrapRef, ComponentCustomProperties, DefineComponent, PublicProps } from 'vue';
+import { DefaultSort } from '../tables/src/data';
+import { EpPropMergeType } from 'element-plus/es/utils';
+import { TableProps, TableColumnCtx, Sort, Filter, Table } from 'element-plus/es/components/table';
+import { default as __DTS_DEFAULT_0__ } from 'element-plus/es/components/table/src/table-layout';
+import { TreeData } from 'element-plus/es/components/table/src/store/tree';
+import { StoreFilter } from 'element-plus/es/components/table/src/store';
+import { TableSortOrder, RenderExpanded, TreeProps } from 'element-plus/es/components/table/src/table/defaults';
+import { DebouncedFunc } from 'lodash';
+import { Translator } from 'element-plus/es/hooks';
+import { OnCleanup } from '@vue/reactivity';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<string, (_: any) => any>> & Partial<Record<string, (_: any) => any>>;
+    refs: {
+        refTable: ({
+            $: ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                value: ObjAny[];
+                list: ListObj[];
+                loading: boolean;
+                options: Record<string, any>;
+                height: string | number;
+                compons: {
+                    [key: string]: Component;
+                };
+                defaultSort: DefaultSort;
+                adaptive: boolean;
+            }> & Omit<{
+                readonly value: ObjAny[];
+                readonly list: ListObj[];
+                readonly loading: boolean;
+                readonly options: Record<string, any>;
+                readonly height: string | number;
+                readonly compons: {
+                    [key: string]: Component;
+                };
+                readonly defaultSort: DefaultSort;
+                readonly adaptive: boolean;
+                readonly lineHeight?: string | number | undefined;
+            } & VNodeProps & AllowedComponentProps & ComponentCustomProps, "value" | "list" | "loading" | "options" | "height" | "compons" | "defaultSort" | "adaptive">;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                tableRef: CreateComponentPublicInstanceWithMixins<Readonly< ExtractPropTypes<{
+                    data: {
+                        type: PropType<any[]>;
+                        default: () => never[];
+                    };
+                    size: {
+                        readonly type: PropType<EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    width: (NumberConstructor | StringConstructor)[];
+                    height: (NumberConstructor | StringConstructor)[];
+                    maxHeight: (NumberConstructor | StringConstructor)[];
+                    fit: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    stripe: BooleanConstructor;
+                    border: BooleanConstructor;
+                    rowKey: PropType< TableProps<any>["rowKey"]>;
+                    showHeader: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    showSummary: BooleanConstructor;
+                    sumText: StringConstructor;
+                    summaryMethod: PropType< TableProps<any>["summaryMethod"]>;
+                    rowClassName: PropType< TableProps<any>["rowClassName"]>;
+                    rowStyle: PropType< TableProps<any>["rowStyle"]>;
+                    cellClassName: PropType< TableProps<any>["cellClassName"]>;
+                    cellStyle: PropType< TableProps<any>["cellStyle"]>;
+                    headerRowClassName: PropType< TableProps<any>["headerRowClassName"]>;
+                    headerRowStyle: PropType< TableProps<any>["headerRowStyle"]>;
+                    headerCellClassName: PropType< TableProps<any>["headerCellClassName"]>;
+                    headerCellStyle: PropType< TableProps<any>["headerCellStyle"]>;
+                    highlightCurrentRow: BooleanConstructor;
+                    currentRowKey: (NumberConstructor | StringConstructor)[];
+                    emptyText: StringConstructor;
+                    expandRowKeys: PropType< TableProps<any>["expandRowKeys"]>;
+                    defaultExpandAll: BooleanConstructor;
+                    defaultSort: PropType< TableProps<any>["defaultSort"]>;
+                    tooltipEffect: StringConstructor;
+                    tooltipOptions: PropType< TableProps<any>["tooltipOptions"]>;
+                    spanMethod: PropType< TableProps<any>["spanMethod"]>;
+                    selectOnIndeterminate: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    indent: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    treeProps: {
+                        type: PropType< TableProps<any>["treeProps"]>;
+                        default: () => {
+                            hasChildren: string;
+                            children: string;
+                            checkStrictly: boolean;
+                        };
+                    };
+                    lazy: BooleanConstructor;
+                    load: PropType< TableProps<any>["load"]>;
+                    style: {
+                        type: PropType<CSSProperties>;
+                        default: () => {};
+                    };
+                    className: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    tableLayout: {
+                        type: PropType<"fixed" | "auto">;
+                        default: string;
+                    };
+                    scrollbarAlwaysOn: BooleanConstructor;
+                    flexible: BooleanConstructor;
+                    showOverflowTooltip: PropType< TableProps<any>["showOverflowTooltip"]>;
+                    tooltipFormatter: PropType< TableProps<any>["tooltipFormatter"]>;
+                    appendFilterPanelTo: StringConstructor;
+                    scrollbarTabindex: {
+                        type: (NumberConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    allowDragLastColumn: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    preserveExpandedContent: BooleanConstructor;
+                }>> & {
+                    onScroll?: ((...args: any[]) => any) | undefined;
+                    onSelect?: ((...args: any[]) => any) | undefined;
+                    "onExpand-change"?: ((...args: any[]) => any) | undefined;
+                    "onCurrent-change"?: ((...args: any[]) => any) | undefined;
+                    "onSelect-all"?: ((...args: any[]) => any) | undefined;
+                    "onHeader-click"?: ((...args: any[]) => any) | undefined;
+                    "onHeader-contextmenu"?: ((...args: any[]) => any) | undefined;
+                    "onHeader-dragend"?: ((...args: any[]) => any) | undefined;
+                    "onSelection-change"?: ((...args: any[]) => any) | undefined;
+                    "onSort-change"?: ((...args: any[]) => any) | undefined;
+                    "onFilter-change"?: ((...args: any[]) => any) | undefined;
+                    "onCell-mouse-enter"?: ((...args: any[]) => any) | undefined;
+                    "onCell-mouse-leave"?: ((...args: any[]) => any) | undefined;
+                    "onCell-contextmenu"?: ((...args: any[]) => any) | undefined;
+                    "onCell-click"?: ((...args: any[]) => any) | undefined;
+                    "onCell-dblclick"?: ((...args: any[]) => any) | undefined;
+                    "onRow-click"?: ((...args: any[]) => any) | undefined;
+                    "onRow-contextmenu"?: ((...args: any[]) => any) | undefined;
+                    "onRow-dblclick"?: ((...args: any[]) => any) | undefined;
+                }, {
+                    ns: {
+                        namespace: ComputedRef<string>;
+                        b: (blockSuffix?: string) => string;
+                        e: (element?: string) => string;
+                        m: (modifier?: string) => string;
+                        be: (blockSuffix?: string, element?: string) => string;
+                        em: (element?: string, modifier?: string) => string;
+                        bm: (blockSuffix?: string, modifier?: string) => string;
+                        bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+                        is: {
+                            (name: string, state: boolean | undefined): string;
+                            (name: string): string;
+                        };
+                        cssVar: (object: Record<string, string>) => Record<string, string>;
+                        cssVarName: (name: string) => string;
+                        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                        cssVarBlockName: (name: string) => string;
+                    };
+                    layout: __DTS_DEFAULT_0__<any>;
+                    store: {
+                        mutations: {
+                            setData(states: {
+                                _currentRowKey: Ref<string | null>;
+                                currentRow: Ref<any>;
+                                expandRowKeys: Ref<(string | number)[]>;
+                                treeData: Ref<Record<string, TreeData>>;
+                                indent: Ref<number>;
+                                lazy: Ref<boolean>;
+                                lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                                lazyColumnIdentifier: Ref<string>;
+                                childrenColumnName: Ref<string>;
+                                checkStrictly: Ref<boolean>;
+                                expandRows: Ref<any[]>;
+                                defaultExpandAll: Ref<boolean>;
+                                tableSize: Ref<any>;
+                                rowKey: Ref<string | null>;
+                                data: Ref<any[]>;
+                                _data: Ref<any[]>;
+                                isComplex: Ref<boolean>;
+                                _columns: Ref< TableColumnCtx<any>[]>;
+                                originColumns: Ref< TableColumnCtx<any>[]>;
+                                columns: Ref< TableColumnCtx<any>[]>;
+                                fixedColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                                leafColumns: Ref< TableColumnCtx<any>[]>;
+                                fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                updateOrderFns: (() => void)[];
+                                leafColumnsLength: Ref<number>;
+                                fixedLeafColumnsLength: Ref<number>;
+                                rightFixedLeafColumnsLength: Ref<number>;
+                                isAllSelected: Ref<boolean>;
+                                selection: Ref<any[]>;
+                                reserveSelection: Ref<boolean>;
+                                selectOnIndeterminate: Ref<boolean>;
+                                selectable: Ref<((row: any, index: number) => boolean) | null>;
+                                filters: Ref<StoreFilter>;
+                                filteredData: Ref<any[] | null>;
+                                sortingColumn: Ref< TableColumnCtx<any> | null>;
+                                sortProp: Ref<string | null>;
+                                sortOrder: Ref<string | number | null>;
+                                hoverRow: Ref<any>;
+                            }, data: any[]): void;
+                            insertColumn(states: {
+                                _currentRowKey: Ref<string | null>;
+                                currentRow: Ref<any>;
+                                expandRowKeys: Ref<(string | number)[]>;
+                                treeData: Ref<Record<string, TreeData>>;
+                                indent: Ref<number>;
+                                lazy: Ref<boolean>;
+                                lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                                lazyColumnIdentifier: Ref<string>;
+                                childrenColumnName: Ref<string>;
+                                checkStrictly: Ref<boolean>;
+                                expandRows: Ref<any[]>;
+                                defaultExpandAll: Ref<boolean>;
+                                tableSize: Ref<any>;
+                                rowKey: Ref<string | null>;
+                                data: Ref<any[]>;
+                                _data: Ref<any[]>;
+                                isComplex: Ref<boolean>;
+                                _columns: Ref< TableColumnCtx<any>[]>;
+                                originColumns: Ref< TableColumnCtx<any>[]>;
+                                columns: Ref< TableColumnCtx<any>[]>;
+                                fixedColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                                leafColumns: Ref< TableColumnCtx<any>[]>;
+                                fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                updateOrderFns: (() => void)[];
+                                leafColumnsLength: Ref<number>;
+                                fixedLeafColumnsLength: Ref<number>;
+                                rightFixedLeafColumnsLength: Ref<number>;
+                                isAllSelected: Ref<boolean>;
+                                selection: Ref<any[]>;
+                                reserveSelection: Ref<boolean>;
+                                selectOnIndeterminate: Ref<boolean>;
+                                selectable: Ref<((row: any, index: number) => boolean) | null>;
+                                filters: Ref<StoreFilter>;
+                                filteredData: Ref<any[] | null>;
+                                sortingColumn: Ref< TableColumnCtx<any> | null>;
+                                sortProp: Ref<string | null>;
+                                sortOrder: Ref<string | number | null>;
+                                hoverRow: Ref<any>;
+                            }, column: TableColumnCtx<any>, parent: TableColumnCtx<any>, updateColumnOrder: () => void): void;
+                            updateColumnOrder(states: {
+                                _currentRowKey: Ref<string | null>;
+                                currentRow: Ref<any>;
+                                expandRowKeys: Ref<(string | number)[]>;
+                                treeData: Ref<Record<string, TreeData>>;
+                                indent: Ref<number>;
+                                lazy: Ref<boolean>;
+                                lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                                lazyColumnIdentifier: Ref<string>;
+                                childrenColumnName: Ref<string>;
+                                checkStrictly: Ref<boolean>;
+                                expandRows: Ref<any[]>;
+                                defaultExpandAll: Ref<boolean>;
+                                tableSize: Ref<any>;
+                                rowKey: Ref<string | null>;
+                                data: Ref<any[]>;
+                                _data: Ref<any[]>;
+                                isComplex: Ref<boolean>;
+                                _columns: Ref< TableColumnCtx<any>[]>;
+                                originColumns: Ref< TableColumnCtx<any>[]>;
+                                columns: Ref< TableColumnCtx<any>[]>;
+                                fixedColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                                leafColumns: Ref< TableColumnCtx<any>[]>;
+                                fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                updateOrderFns: (() => void)[];
+                                leafColumnsLength: Ref<number>;
+                                fixedLeafColumnsLength: Ref<number>;
+                                rightFixedLeafColumnsLength: Ref<number>;
+                                isAllSelected: Ref<boolean>;
+                                selection: Ref<any[]>;
+                                reserveSelection: Ref<boolean>;
+                                selectOnIndeterminate: Ref<boolean>;
+                                selectable: Ref<((row: any, index: number) => boolean) | null>;
+                                filters: Ref<StoreFilter>;
+                                filteredData: Ref<any[] | null>;
+                                sortingColumn: Ref< TableColumnCtx<any> | null>;
+                                sortProp: Ref<string | null>;
+                                sortOrder: Ref<string | number | null>;
+                                hoverRow: Ref<any>;
+                            }, column: TableColumnCtx<any>): void;
+                            removeColumn(states: {
+                                _currentRowKey: Ref<string | null>;
+                                currentRow: Ref<any>;
+                                expandRowKeys: Ref<(string | number)[]>;
+                                treeData: Ref<Record<string, TreeData>>;
+                                indent: Ref<number>;
+                                lazy: Ref<boolean>;
+                                lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                                lazyColumnIdentifier: Ref<string>;
+                                childrenColumnName: Ref<string>;
+                                checkStrictly: Ref<boolean>;
+                                expandRows: Ref<any[]>;
+                                defaultExpandAll: Ref<boolean>;
+                                tableSize: Ref<any>;
+                                rowKey: Ref<string | null>;
+                                data: Ref<any[]>;
+                                _data: Ref<any[]>;
+                                isComplex: Ref<boolean>;
+                                _columns: Ref< TableColumnCtx<any>[]>;
+                                originColumns: Ref< TableColumnCtx<any>[]>;
+                                columns: Ref< TableColumnCtx<any>[]>;
+                                fixedColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                                leafColumns: Ref< TableColumnCtx<any>[]>;
+                                fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                updateOrderFns: (() => void)[];
+                                leafColumnsLength: Ref<number>;
+                                fixedLeafColumnsLength: Ref<number>;
+                                rightFixedLeafColumnsLength: Ref<number>;
+                                isAllSelected: Ref<boolean>;
+                                selection: Ref<any[]>;
+                                reserveSelection: Ref<boolean>;
+                                selectOnIndeterminate: Ref<boolean>;
+                                selectable: Ref<((row: any, index: number) => boolean) | null>;
+                                filters: Ref<StoreFilter>;
+                                filteredData: Ref<any[] | null>;
+                                sortingColumn: Ref< TableColumnCtx<any> | null>;
+                                sortProp: Ref<string | null>;
+                                sortOrder: Ref<string | number | null>;
+                                hoverRow: Ref<any>;
+                            }, column: TableColumnCtx<any>, parent: TableColumnCtx<any>, updateColumnOrder: () => void): void;
+                            sort(states: {
+                                _currentRowKey: Ref<string | null>;
+                                currentRow: Ref<any>;
+                                expandRowKeys: Ref<(string | number)[]>;
+                                treeData: Ref<Record<string, TreeData>>;
+                                indent: Ref<number>;
+                                lazy: Ref<boolean>;
+                                lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                                lazyColumnIdentifier: Ref<string>;
+                                childrenColumnName: Ref<string>;
+                                checkStrictly: Ref<boolean>;
+                                expandRows: Ref<any[]>;
+                                defaultExpandAll: Ref<boolean>;
+                                tableSize: Ref<any>;
+                                rowKey: Ref<string | null>;
+                                data: Ref<any[]>;
+                                _data: Ref<any[]>;
+                                isComplex: Ref<boolean>;
+                                _columns: Ref< TableColumnCtx<any>[]>;
+                                originColumns: Ref< TableColumnCtx<any>[]>;
+                                columns: Ref< TableColumnCtx<any>[]>;
+                                fixedColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                                leafColumns: Ref< TableColumnCtx<any>[]>;
+                                fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                updateOrderFns: (() => void)[];
+                                leafColumnsLength: Ref<number>;
+                                fixedLeafColumnsLength: Ref<number>;
+                                rightFixedLeafColumnsLength: Ref<number>;
+                                isAllSelected: Ref<boolean>;
+                                selection: Ref<any[]>;
+                                reserveSelection: Ref<boolean>;
+                                selectOnIndeterminate: Ref<boolean>;
+                                selectable: Ref<((row: any, index: number) => boolean) | null>;
+                                filters: Ref<StoreFilter>;
+                                filteredData: Ref<any[] | null>;
+                                sortingColumn: Ref< TableColumnCtx<any> | null>;
+                                sortProp: Ref<string | null>;
+                                sortOrder: Ref<string | number | null>;
+                                hoverRow: Ref<any>;
+                            }, options: Sort): void;
+                            changeSortCondition(states: {
+                                _currentRowKey: Ref<string | null>;
+                                currentRow: Ref<any>;
+                                expandRowKeys: Ref<(string | number)[]>;
+                                treeData: Ref<Record<string, TreeData>>;
+                                indent: Ref<number>;
+                                lazy: Ref<boolean>;
+                                lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                                lazyColumnIdentifier: Ref<string>;
+                                childrenColumnName: Ref<string>;
+                                checkStrictly: Ref<boolean>;
+                                expandRows: Ref<any[]>;
+                                defaultExpandAll: Ref<boolean>;
+                                tableSize: Ref<any>;
+                                rowKey: Ref<string | null>;
+                                data: Ref<any[]>;
+                                _data: Ref<any[]>;
+                                isComplex: Ref<boolean>;
+                                _columns: Ref< TableColumnCtx<any>[]>;
+                                originColumns: Ref< TableColumnCtx<any>[]>;
+                                columns: Ref< TableColumnCtx<any>[]>;
+                                fixedColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                                leafColumns: Ref< TableColumnCtx<any>[]>;
+                                fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                updateOrderFns: (() => void)[];
+                                leafColumnsLength: Ref<number>;
+                                fixedLeafColumnsLength: Ref<number>;
+                                rightFixedLeafColumnsLength: Ref<number>;
+                                isAllSelected: Ref<boolean>;
+                                selection: Ref<any[]>;
+                                reserveSelection: Ref<boolean>;
+                                selectOnIndeterminate: Ref<boolean>;
+                                selectable: Ref<((row: any, index: number) => boolean) | null>;
+                                filters: Ref<StoreFilter>;
+                                filteredData: Ref<any[] | null>;
+                                sortingColumn: Ref< TableColumnCtx<any> | null>;
+                                sortProp: Ref<string | null>;
+                                sortOrder: Ref<string | number | null>;
+                                hoverRow: Ref<any>;
+                            }, options: Sort): void;
+                            filterChange(_states: {
+                                _currentRowKey: Ref<string | null>;
+                                currentRow: Ref<any>;
+                                expandRowKeys: Ref<(string | number)[]>;
+                                treeData: Ref<Record<string, TreeData>>;
+                                indent: Ref<number>;
+                                lazy: Ref<boolean>;
+                                lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                                lazyColumnIdentifier: Ref<string>;
+                                childrenColumnName: Ref<string>;
+                                checkStrictly: Ref<boolean>;
+                                expandRows: Ref<any[]>;
+                                defaultExpandAll: Ref<boolean>;
+                                tableSize: Ref<any>;
+                                rowKey: Ref<string | null>;
+                                data: Ref<any[]>;
+                                _data: Ref<any[]>;
+                                isComplex: Ref<boolean>;
+                                _columns: Ref< TableColumnCtx<any>[]>;
+                                originColumns: Ref< TableColumnCtx<any>[]>;
+                                columns: Ref< TableColumnCtx<any>[]>;
+                                fixedColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                                leafColumns: Ref< TableColumnCtx<any>[]>;
+                                fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                updateOrderFns: (() => void)[];
+                                leafColumnsLength: Ref<number>;
+                                fixedLeafColumnsLength: Ref<number>;
+                                rightFixedLeafColumnsLength: Ref<number>;
+                                isAllSelected: Ref<boolean>;
+                                selection: Ref<any[]>;
+                                reserveSelection: Ref<boolean>;
+                                selectOnIndeterminate: Ref<boolean>;
+                                selectable: Ref<((row: any, index: number) => boolean) | null>;
+                                filters: Ref<StoreFilter>;
+                                filteredData: Ref<any[] | null>;
+                                sortingColumn: Ref< TableColumnCtx<any> | null>;
+                                sortProp: Ref<string | null>;
+                                sortOrder: Ref<string | number | null>;
+                                hoverRow: Ref<any>;
+                            }, options: Filter<any>): void;
+                            toggleAllSelection(): void;
+                            rowSelectedChanged(_states: {
+                                _currentRowKey: Ref<string | null>;
+                                currentRow: Ref<any>;
+                                expandRowKeys: Ref<(string | number)[]>;
+                                treeData: Ref<Record<string, TreeData>>;
+                                indent: Ref<number>;
+                                lazy: Ref<boolean>;
+                                lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                                lazyColumnIdentifier: Ref<string>;
+                                childrenColumnName: Ref<string>;
+                                checkStrictly: Ref<boolean>;
+                                expandRows: Ref<any[]>;
+                                defaultExpandAll: Ref<boolean>;
+                                tableSize: Ref<any>;
+                                rowKey: Ref<string | null>;
+                                data: Ref<any[]>;
+                                _data: Ref<any[]>;
+                                isComplex: Ref<boolean>;
+                                _columns: Ref< TableColumnCtx<any>[]>;
+                                originColumns: Ref< TableColumnCtx<any>[]>;
+                                columns: Ref< TableColumnCtx<any>[]>;
+                                fixedColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                                leafColumns: Ref< TableColumnCtx<any>[]>;
+                                fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                updateOrderFns: (() => void)[];
+                                leafColumnsLength: Ref<number>;
+                                fixedLeafColumnsLength: Ref<number>;
+                                rightFixedLeafColumnsLength: Ref<number>;
+                                isAllSelected: Ref<boolean>;
+                                selection: Ref<any[]>;
+                                reserveSelection: Ref<boolean>;
+                                selectOnIndeterminate: Ref<boolean>;
+                                selectable: Ref<((row: any, index: number) => boolean) | null>;
+                                filters: Ref<StoreFilter>;
+                                filteredData: Ref<any[] | null>;
+                                sortingColumn: Ref< TableColumnCtx<any> | null>;
+                                sortProp: Ref<string | null>;
+                                sortOrder: Ref<string | number | null>;
+                                hoverRow: Ref<any>;
+                            }, row: any): void;
+                            setHoverRow(states: {
+                                _currentRowKey: Ref<string | null>;
+                                currentRow: Ref<any>;
+                                expandRowKeys: Ref<(string | number)[]>;
+                                treeData: Ref<Record<string, TreeData>>;
+                                indent: Ref<number>;
+                                lazy: Ref<boolean>;
+                                lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                                lazyColumnIdentifier: Ref<string>;
+                                childrenColumnName: Ref<string>;
+                                checkStrictly: Ref<boolean>;
+                                expandRows: Ref<any[]>;
+                                defaultExpandAll: Ref<boolean>;
+                                tableSize: Ref<any>;
+                                rowKey: Ref<string | null>;
+                                data: Ref<any[]>;
+                                _data: Ref<any[]>;
+                                isComplex: Ref<boolean>;
+                                _columns: Ref< TableColumnCtx<any>[]>;
+                                originColumns: Ref< TableColumnCtx<any>[]>;
+                                columns: Ref< TableColumnCtx<any>[]>;
+                                fixedColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                                leafColumns: Ref< TableColumnCtx<any>[]>;
+                                fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                updateOrderFns: (() => void)[];
+                                leafColumnsLength: Ref<number>;
+                                fixedLeafColumnsLength: Ref<number>;
+                                rightFixedLeafColumnsLength: Ref<number>;
+                                isAllSelected: Ref<boolean>;
+                                selection: Ref<any[]>;
+                                reserveSelection: Ref<boolean>;
+                                selectOnIndeterminate: Ref<boolean>;
+                                selectable: Ref<((row: any, index: number) => boolean) | null>;
+                                filters: Ref<StoreFilter>;
+                                filteredData: Ref<any[] | null>;
+                                sortingColumn: Ref< TableColumnCtx<any> | null>;
+                                sortProp: Ref<string | null>;
+                                sortOrder: Ref<string | number | null>;
+                                hoverRow: Ref<any>;
+                            }, row: any): void;
+                            setCurrentRow(_states: {
+                                _currentRowKey: Ref<string | null>;
+                                currentRow: Ref<any>;
+                                expandRowKeys: Ref<(string | number)[]>;
+                                treeData: Ref<Record<string, TreeData>>;
+                                indent: Ref<number>;
+                                lazy: Ref<boolean>;
+                                lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                                lazyColumnIdentifier: Ref<string>;
+                                childrenColumnName: Ref<string>;
+                                checkStrictly: Ref<boolean>;
+                                expandRows: Ref<any[]>;
+                                defaultExpandAll: Ref<boolean>;
+                                tableSize: Ref<any>;
+                                rowKey: Ref<string | null>;
+                                data: Ref<any[]>;
+                                _data: Ref<any[]>;
+                                isComplex: Ref<boolean>;
+                                _columns: Ref< TableColumnCtx<any>[]>;
+                                originColumns: Ref< TableColumnCtx<any>[]>;
+                                columns: Ref< TableColumnCtx<any>[]>;
+                                fixedColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                                leafColumns: Ref< TableColumnCtx<any>[]>;
+                                fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                updateOrderFns: (() => void)[];
+                                leafColumnsLength: Ref<number>;
+                                fixedLeafColumnsLength: Ref<number>;
+                                rightFixedLeafColumnsLength: Ref<number>;
+                                isAllSelected: Ref<boolean>;
+                                selection: Ref<any[]>;
+                                reserveSelection: Ref<boolean>;
+                                selectOnIndeterminate: Ref<boolean>;
+                                selectable: Ref<((row: any, index: number) => boolean) | null>;
+                                filters: Ref<StoreFilter>;
+                                filteredData: Ref<any[] | null>;
+                                sortingColumn: Ref< TableColumnCtx<any> | null>;
+                                sortProp: Ref<string | null>;
+                                sortOrder: Ref<string | number | null>;
+                                hoverRow: Ref<any>;
+                            }, row: any): void;
+                        };
+                        commit: (name: "sort" | "setData" | "insertColumn" | "updateColumnOrder" | "removeColumn" | "changeSortCondition" | "filterChange" | "toggleAllSelection" | "rowSelectedChanged" | "setHoverRow" | "setCurrentRow", ...args: any[]) => void;
+                        updateTableScrollY: () => void;
+                        assertRowKey: () => void;
+                        updateColumns: () => void;
+                        scheduleLayout: (needUpdateColumns?: boolean, immediate?: boolean) => void;
+                        isSelected: (row: any) => boolean;
+                        clearSelection: () => void;
+                        cleanSelection: () => void;
+                        getSelectionRows: () => any[];
+                        toggleRowSelection: (row: any, selected?: boolean, emitChange?: boolean, ignoreSelectable?: boolean) => void;
+                        _toggleAllSelection: () => void;
+                        toggleAllSelection: (() => void) | null;
+                        updateAllSelected: () => void;
+                        updateFilters: (column: TableColumnCtx<any>, values: string[]) => Record<string, string[]>;
+                        updateCurrentRow: (_currentRow: any) => void;
+                        updateSort: (column: TableColumnCtx<any> | null, prop: string | null, order: TableSortOrder | null) => void;
+                        execFilter: () => void;
+                        execSort: () => void;
+                        execQuery: (ignore?: {
+                            filter: boolean;
+                        } | undefined) => void;
+                        clearFilter: (columnKeys?: string[] | string) => void;
+                        clearSort: () => void;
+                        toggleRowExpansion: (row: any, expanded?: boolean) => void;
+                        setExpandRowKeysAdapter: (val: (string | number)[]) => void;
+                        setCurrentRowKey: (key: string) => void;
+                        toggleRowExpansionAdapter: (row: any, expanded?: boolean) => void;
+                        isRowExpanded: (row: any) => boolean;
+                        updateExpandRows: () => void;
+                        updateCurrentRowData: () => void;
+                        loadOrToggle: (row: any) => void;
+                        updateTreeData: (ifChangeExpandRowKeys?: boolean, ifExpandAll?: boolean) => void;
+                        updateKeyChildren: (key: string, data: any[]) => void;
+                        states: {
+                            _currentRowKey: Ref<string | null>;
+                            currentRow: Ref<any>;
+                            expandRowKeys: Ref<(string | number)[]>;
+                            treeData: Ref<Record<string, TreeData>>;
+                            indent: Ref<number>;
+                            lazy: Ref<boolean>;
+                            lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                            lazyColumnIdentifier: Ref<string>;
+                            childrenColumnName: Ref<string>;
+                            checkStrictly: Ref<boolean>;
+                            expandRows: Ref<any[]>;
+                            defaultExpandAll: Ref<boolean>;
+                            tableSize: Ref<any>;
+                            rowKey: Ref<string | null>;
+                            data: Ref<any[]>;
+                            _data: Ref<any[]>;
+                            isComplex: Ref<boolean>;
+                            _columns: Ref< TableColumnCtx<any>[]>;
+                            originColumns: Ref< TableColumnCtx<any>[]>;
+                            columns: Ref< TableColumnCtx<any>[]>;
+                            fixedColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                            leafColumns: Ref< TableColumnCtx<any>[]>;
+                            fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            updateOrderFns: (() => void)[];
+                            leafColumnsLength: Ref<number>;
+                            fixedLeafColumnsLength: Ref<number>;
+                            rightFixedLeafColumnsLength: Ref<number>;
+                            isAllSelected: Ref<boolean>;
+                            selection: Ref<any[]>;
+                            reserveSelection: Ref<boolean>;
+                            selectOnIndeterminate: Ref<boolean>;
+                            selectable: Ref<((row: any, index: number) => boolean) | null>;
+                            filters: Ref<StoreFilter>;
+                            filteredData: Ref<any[] | null>;
+                            sortingColumn: Ref< TableColumnCtx<any> | null>;
+                            sortProp: Ref<string | null>;
+                            sortOrder: Ref<string | number | null>;
+                            hoverRow: Ref<any>;
+                        };
+                        ns: {
+                            namespace: ComputedRef<string>;
+                            b: (blockSuffix?: string) => string;
+                            e: (element?: string) => string;
+                            m: (modifier?: string) => string;
+                            be: (blockSuffix?: string, element?: string) => string;
+                            em: (element?: string, modifier?: string) => string;
+                            bm: (blockSuffix?: string, modifier?: string) => string;
+                            bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+                            is: {
+                                (name: string, state: boolean | undefined): string;
+                                (name: string): string;
+                            };
+                            cssVar: (object: Record<string, string>) => Record<string, string>;
+                            cssVarName: (name: string) => string;
+                            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                            cssVarBlockName: (name: string) => string;
+                        };
+                    };
+                    columns: ComputedRef< TableColumnCtx<any>[]>;
+                    handleHeaderFooterMousewheel: (_event: WheelEvent, data: any) => void;
+                    handleMouseLeave: () => void;
+                    tableId: string;
+                    tableSize: ComputedRef<"" | "small" | "default" | "large">;
+                    isHidden: Ref<boolean>;
+                    isEmpty: ComputedRef<boolean>;
+                    renderExpanded: Ref< RenderExpanded<any> | null>;
+                    resizeProxyVisible: Ref<boolean>;
+                    resizeState: Ref<{
+                        width: null | number;
+                        height: null | number;
+                        headerHeight: null | number;
+                    }>;
+                    isGroup: Ref<boolean>;
+                    bodyWidth: ComputedRef<string>;
+                    tableBodyStyles: ComputedRef<{
+                        width: string;
+                    }>;
+                    emptyBlockStyle: ComputedRef<{
+                        width: string;
+                        height: string;
+                    } | undefined>;
+                    debouncedUpdateLayout: DebouncedFunc<() => void>;
+                    setCurrentRow: (row: any) => void;
+                    getSelectionRows: () => any[];
+                    toggleRowSelection: (row: any, selected?: boolean, ignoreSelectable?: boolean) => void;
+                    clearSelection: () => void;
+                    clearFilter: (columnKeys?: string[] | string) => void;
+                    toggleAllSelection: () => void;
+                    toggleRowExpansion: (row: any, expanded?: boolean) => void;
+                    clearSort: () => void;
+                    doLayout: () => void;
+                    sort: (prop: string, order: string) => void;
+                    updateKeyChildren: (key: string, data: any[]) => void;
+                    t: Translator;
+                    setDragVisible: (visible: boolean) => void;
+                    context: Table<any>;
+                    computedSumText: ComputedRef<string>;
+                    computedEmptyText: ComputedRef<string>;
+                    tableLayout: ComputedRef<("fixed" | "auto") | undefined>;
+                    scrollbarViewStyle: {
+                        display: string;
+                        verticalAlign: string;
+                    };
+                    scrollbarStyle: ComputedRef<{
+                        height: string;
+                        maxHeight?: undefined;
+                    } | {
+                        maxHeight: string;
+                        height?: undefined;
+                    } | {
+                        height?: undefined;
+                        maxHeight?: undefined;
+                    }>;
+                    scrollBarRef: Ref<any>;
+                    scrollTo: (options: ScrollToOptions | number, yCoord?: number) => void;
+                    setScrollLeft: (left?: number) => void;
+                    setScrollTop: (top?: number) => void;
+                    allowDragLastColumn: boolean;
+                }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("select" | "expand-change" | "scroll" | "sort-change" | "row-click" | "select-all" | "current-change" | "header-click" | "header-contextmenu" | "header-dragend" | "selection-change" | "filter-change" | "cell-mouse-enter" | "cell-mouse-leave" | "cell-contextmenu" | "cell-click" | "cell-dblclick" | "row-contextmenu" | "row-dblclick")[], VNodeProps & AllowedComponentProps & ComponentCustomProps, {
+                    data: any[];
+                    style: CSSProperties;
+                    tableLayout: "fixed" | "auto";
+                    border: boolean;
+                    className: string;
+                    fit: boolean;
+                    lazy: boolean;
+                    scrollbarAlwaysOn: boolean;
+                    allowDragLastColumn: boolean;
+                    treeProps: TreeProps | undefined;
+                    defaultExpandAll: boolean;
+                    selectOnIndeterminate: boolean;
+                    indent: number;
+                    stripe: boolean;
+                    showHeader: boolean;
+                    showSummary: boolean;
+                    highlightCurrentRow: boolean;
+                    flexible: boolean;
+                    scrollbarTabindex: string | number;
+                    preserveExpandedContent: boolean;
+                }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly< ExtractPropTypes<{
+                    data: {
+                        type: PropType<any[]>;
+                        default: () => never[];
+                    };
+                    size: {
+                        readonly type: PropType<EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    width: (NumberConstructor | StringConstructor)[];
+                    height: (NumberConstructor | StringConstructor)[];
+                    maxHeight: (NumberConstructor | StringConstructor)[];
+                    fit: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    stripe: BooleanConstructor;
+                    border: BooleanConstructor;
+                    rowKey: PropType< TableProps<any>["rowKey"]>;
+                    showHeader: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    showSummary: BooleanConstructor;
+                    sumText: StringConstructor;
+                    summaryMethod: PropType< TableProps<any>["summaryMethod"]>;
+                    rowClassName: PropType< TableProps<any>["rowClassName"]>;
+                    rowStyle: PropType< TableProps<any>["rowStyle"]>;
+                    cellClassName: PropType< TableProps<any>["cellClassName"]>;
+                    cellStyle: PropType< TableProps<any>["cellStyle"]>;
+                    headerRowClassName: PropType< TableProps<any>["headerRowClassName"]>;
+                    headerRowStyle: PropType< TableProps<any>["headerRowStyle"]>;
+                    headerCellClassName: PropType< TableProps<any>["headerCellClassName"]>;
+                    headerCellStyle: PropType< TableProps<any>["headerCellStyle"]>;
+                    highlightCurrentRow: BooleanConstructor;
+                    currentRowKey: (NumberConstructor | StringConstructor)[];
+                    emptyText: StringConstructor;
+                    expandRowKeys: PropType< TableProps<any>["expandRowKeys"]>;
+                    defaultExpandAll: BooleanConstructor;
+                    defaultSort: PropType< TableProps<any>["defaultSort"]>;
+                    tooltipEffect: StringConstructor;
+                    tooltipOptions: PropType< TableProps<any>["tooltipOptions"]>;
+                    spanMethod: PropType< TableProps<any>["spanMethod"]>;
+                    selectOnIndeterminate: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    indent: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    treeProps: {
+                        type: PropType< TableProps<any>["treeProps"]>;
+                        default: () => {
+                            hasChildren: string;
+                            children: string;
+                            checkStrictly: boolean;
+                        };
+                    };
+                    lazy: BooleanConstructor;
+                    load: PropType< TableProps<any>["load"]>;
+                    style: {
+                        type: PropType<CSSProperties>;
+                        default: () => {};
+                    };
+                    className: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    tableLayout: {
+                        type: PropType<"fixed" | "auto">;
+                        default: string;
+                    };
+                    scrollbarAlwaysOn: BooleanConstructor;
+                    flexible: BooleanConstructor;
+                    showOverflowTooltip: PropType< TableProps<any>["showOverflowTooltip"]>;
+                    tooltipFormatter: PropType< TableProps<any>["tooltipFormatter"]>;
+                    appendFilterPanelTo: StringConstructor;
+                    scrollbarTabindex: {
+                        type: (NumberConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    allowDragLastColumn: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    preserveExpandedContent: BooleanConstructor;
+                }>> & {
+                    onScroll?: ((...args: any[]) => any) | undefined;
+                    onSelect?: ((...args: any[]) => any) | undefined;
+                    "onExpand-change"?: ((...args: any[]) => any) | undefined;
+                    "onCurrent-change"?: ((...args: any[]) => any) | undefined;
+                    "onSelect-all"?: ((...args: any[]) => any) | undefined;
+                    "onHeader-click"?: ((...args: any[]) => any) | undefined;
+                    "onHeader-contextmenu"?: ((...args: any[]) => any) | undefined;
+                    "onHeader-dragend"?: ((...args: any[]) => any) | undefined;
+                    "onSelection-change"?: ((...args: any[]) => any) | undefined;
+                    "onSort-change"?: ((...args: any[]) => any) | undefined;
+                    "onFilter-change"?: ((...args: any[]) => any) | undefined;
+                    "onCell-mouse-enter"?: ((...args: any[]) => any) | undefined;
+                    "onCell-mouse-leave"?: ((...args: any[]) => any) | undefined;
+                    "onCell-contextmenu"?: ((...args: any[]) => any) | undefined;
+                    "onCell-click"?: ((...args: any[]) => any) | undefined;
+                    "onCell-dblclick"?: ((...args: any[]) => any) | undefined;
+                    "onRow-click"?: ((...args: any[]) => any) | undefined;
+                    "onRow-contextmenu"?: ((...args: any[]) => any) | undefined;
+                    "onRow-dblclick"?: ((...args: any[]) => any) | undefined;
+                }, {
+                    ns: {
+                        namespace: ComputedRef<string>;
+                        b: (blockSuffix?: string) => string;
+                        e: (element?: string) => string;
+                        m: (modifier?: string) => string;
+                        be: (blockSuffix?: string, element?: string) => string;
+                        em: (element?: string, modifier?: string) => string;
+                        bm: (blockSuffix?: string, modifier?: string) => string;
+                        bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+                        is: {
+                            (name: string, state: boolean | undefined): string;
+                            (name: string): string;
+                        };
+                        cssVar: (object: Record<string, string>) => Record<string, string>;
+                        cssVarName: (name: string) => string;
+                        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                        cssVarBlockName: (name: string) => string;
+                    };
+                    layout: __DTS_DEFAULT_0__<any>;
+                    store: {
+                        mutations: {
+                            setData(states: {
+                                _currentRowKey: Ref<string | null>;
+                                currentRow: Ref<any>;
+                                expandRowKeys: Ref<(string | number)[]>;
+                                treeData: Ref<Record<string, TreeData>>;
+                                indent: Ref<number>;
+                                lazy: Ref<boolean>;
+                                lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                                lazyColumnIdentifier: Ref<string>;
+                                childrenColumnName: Ref<string>;
+                                checkStrictly: Ref<boolean>;
+                                expandRows: Ref<any[]>;
+                                defaultExpandAll: Ref<boolean>;
+                                tableSize: Ref<any>;
+                                rowKey: Ref<string | null>;
+                                data: Ref<any[]>;
+                                _data: Ref<any[]>;
+                                isComplex: Ref<boolean>;
+                                _columns: Ref< TableColumnCtx<any>[]>;
+                                originColumns: Ref< TableColumnCtx<any>[]>;
+                                columns: Ref< TableColumnCtx<any>[]>;
+                                fixedColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                                leafColumns: Ref< TableColumnCtx<any>[]>;
+                                fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                updateOrderFns: (() => void)[];
+                                leafColumnsLength: Ref<number>;
+                                fixedLeafColumnsLength: Ref<number>;
+                                rightFixedLeafColumnsLength: Ref<number>;
+                                isAllSelected: Ref<boolean>;
+                                selection: Ref<any[]>;
+                                reserveSelection: Ref<boolean>;
+                                selectOnIndeterminate: Ref<boolean>;
+                                selectable: Ref<((row: any, index: number) => boolean) | null>;
+                                filters: Ref<StoreFilter>;
+                                filteredData: Ref<any[] | null>;
+                                sortingColumn: Ref< TableColumnCtx<any> | null>;
+                                sortProp: Ref<string | null>;
+                                sortOrder: Ref<string | number | null>;
+                                hoverRow: Ref<any>;
+                            }, data: any[]): void;
+                            insertColumn(states: {
+                                _currentRowKey: Ref<string | null>;
+                                currentRow: Ref<any>;
+                                expandRowKeys: Ref<(string | number)[]>;
+                                treeData: Ref<Record<string, TreeData>>;
+                                indent: Ref<number>;
+                                lazy: Ref<boolean>;
+                                lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                                lazyColumnIdentifier: Ref<string>;
+                                childrenColumnName: Ref<string>;
+                                checkStrictly: Ref<boolean>;
+                                expandRows: Ref<any[]>;
+                                defaultExpandAll: Ref<boolean>;
+                                tableSize: Ref<any>;
+                                rowKey: Ref<string | null>;
+                                data: Ref<any[]>;
+                                _data: Ref<any[]>;
+                                isComplex: Ref<boolean>;
+                                _columns: Ref< TableColumnCtx<any>[]>;
+                                originColumns: Ref< TableColumnCtx<any>[]>;
+                                columns: Ref< TableColumnCtx<any>[]>;
+                                fixedColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                                leafColumns: Ref< TableColumnCtx<any>[]>;
+                                fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                updateOrderFns: (() => void)[];
+                                leafColumnsLength: Ref<number>;
+                                fixedLeafColumnsLength: Ref<number>;
+                                rightFixedLeafColumnsLength: Ref<number>;
+                                isAllSelected: Ref<boolean>;
+                                selection: Ref<any[]>;
+                                reserveSelection: Ref<boolean>;
+                                selectOnIndeterminate: Ref<boolean>;
+                                selectable: Ref<((row: any, index: number) => boolean) | null>;
+                                filters: Ref<StoreFilter>;
+                                filteredData: Ref<any[] | null>;
+                                sortingColumn: Ref< TableColumnCtx<any> | null>;
+                                sortProp: Ref<string | null>;
+                                sortOrder: Ref<string | number | null>;
+                                hoverRow: Ref<any>;
+                            }, column: TableColumnCtx<any>, parent: TableColumnCtx<any>, updateColumnOrder: () => void): void;
+                            updateColumnOrder(states: {
+                                _currentRowKey: Ref<string | null>;
+                                currentRow: Ref<any>;
+                                expandRowKeys: Ref<(string | number)[]>;
+                                treeData: Ref<Record<string, TreeData>>;
+                                indent: Ref<number>;
+                                lazy: Ref<boolean>;
+                                lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                                lazyColumnIdentifier: Ref<string>;
+                                childrenColumnName: Ref<string>;
+                                checkStrictly: Ref<boolean>;
+                                expandRows: Ref<any[]>;
+                                defaultExpandAll: Ref<boolean>;
+                                tableSize: Ref<any>;
+                                rowKey: Ref<string | null>;
+                                data: Ref<any[]>;
+                                _data: Ref<any[]>;
+                                isComplex: Ref<boolean>;
+                                _columns: Ref< TableColumnCtx<any>[]>;
+                                originColumns: Ref< TableColumnCtx<any>[]>;
+                                columns: Ref< TableColumnCtx<any>[]>;
+                                fixedColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                                leafColumns: Ref< TableColumnCtx<any>[]>;
+                                fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                updateOrderFns: (() => void)[];
+                                leafColumnsLength: Ref<number>;
+                                fixedLeafColumnsLength: Ref<number>;
+                                rightFixedLeafColumnsLength: Ref<number>;
+                                isAllSelected: Ref<boolean>;
+                                selection: Ref<any[]>;
+                                reserveSelection: Ref<boolean>;
+                                selectOnIndeterminate: Ref<boolean>;
+                                selectable: Ref<((row: any, index: number) => boolean) | null>;
+                                filters: Ref<StoreFilter>;
+                                filteredData: Ref<any[] | null>;
+                                sortingColumn: Ref< TableColumnCtx<any> | null>;
+                                sortProp: Ref<string | null>;
+                                sortOrder: Ref<string | number | null>;
+                                hoverRow: Ref<any>;
+                            }, column: TableColumnCtx<any>): void;
+                            removeColumn(states: {
+                                _currentRowKey: Ref<string | null>;
+                                currentRow: Ref<any>;
+                                expandRowKeys: Ref<(string | number)[]>;
+                                treeData: Ref<Record<string, TreeData>>;
+                                indent: Ref<number>;
+                                lazy: Ref<boolean>;
+                                lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                                lazyColumnIdentifier: Ref<string>;
+                                childrenColumnName: Ref<string>;
+                                checkStrictly: Ref<boolean>;
+                                expandRows: Ref<any[]>;
+                                defaultExpandAll: Ref<boolean>;
+                                tableSize: Ref<any>;
+                                rowKey: Ref<string | null>;
+                                data: Ref<any[]>;
+                                _data: Ref<any[]>;
+                                isComplex: Ref<boolean>;
+                                _columns: Ref< TableColumnCtx<any>[]>;
+                                originColumns: Ref< TableColumnCtx<any>[]>;
+                                columns: Ref< TableColumnCtx<any>[]>;
+                                fixedColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                                leafColumns: Ref< TableColumnCtx<any>[]>;
+                                fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                updateOrderFns: (() => void)[];
+                                leafColumnsLength: Ref<number>;
+                                fixedLeafColumnsLength: Ref<number>;
+                                rightFixedLeafColumnsLength: Ref<number>;
+                                isAllSelected: Ref<boolean>;
+                                selection: Ref<any[]>;
+                                reserveSelection: Ref<boolean>;
+                                selectOnIndeterminate: Ref<boolean>;
+                                selectable: Ref<((row: any, index: number) => boolean) | null>;
+                                filters: Ref<StoreFilter>;
+                                filteredData: Ref<any[] | null>;
+                                sortingColumn: Ref< TableColumnCtx<any> | null>;
+                                sortProp: Ref<string | null>;
+                                sortOrder: Ref<string | number | null>;
+                                hoverRow: Ref<any>;
+                            }, column: TableColumnCtx<any>, parent: TableColumnCtx<any>, updateColumnOrder: () => void): void;
+                            sort(states: {
+                                _currentRowKey: Ref<string | null>;
+                                currentRow: Ref<any>;
+                                expandRowKeys: Ref<(string | number)[]>;
+                                treeData: Ref<Record<string, TreeData>>;
+                                indent: Ref<number>;
+                                lazy: Ref<boolean>;
+                                lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                                lazyColumnIdentifier: Ref<string>;
+                                childrenColumnName: Ref<string>;
+                                checkStrictly: Ref<boolean>;
+                                expandRows: Ref<any[]>;
+                                defaultExpandAll: Ref<boolean>;
+                                tableSize: Ref<any>;
+                                rowKey: Ref<string | null>;
+                                data: Ref<any[]>;
+                                _data: Ref<any[]>;
+                                isComplex: Ref<boolean>;
+                                _columns: Ref< TableColumnCtx<any>[]>;
+                                originColumns: Ref< TableColumnCtx<any>[]>;
+                                columns: Ref< TableColumnCtx<any>[]>;
+                                fixedColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                                leafColumns: Ref< TableColumnCtx<any>[]>;
+                                fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                updateOrderFns: (() => void)[];
+                                leafColumnsLength: Ref<number>;
+                                fixedLeafColumnsLength: Ref<number>;
+                                rightFixedLeafColumnsLength: Ref<number>;
+                                isAllSelected: Ref<boolean>;
+                                selection: Ref<any[]>;
+                                reserveSelection: Ref<boolean>;
+                                selectOnIndeterminate: Ref<boolean>;
+                                selectable: Ref<((row: any, index: number) => boolean) | null>;
+                                filters: Ref<StoreFilter>;
+                                filteredData: Ref<any[] | null>;
+                                sortingColumn: Ref< TableColumnCtx<any> | null>;
+                                sortProp: Ref<string | null>;
+                                sortOrder: Ref<string | number | null>;
+                                hoverRow: Ref<any>;
+                            }, options: Sort): void;
+                            changeSortCondition(states: {
+                                _currentRowKey: Ref<string | null>;
+                                currentRow: Ref<any>;
+                                expandRowKeys: Ref<(string | number)[]>;
+                                treeData: Ref<Record<string, TreeData>>;
+                                indent: Ref<number>;
+                                lazy: Ref<boolean>;
+                                lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                                lazyColumnIdentifier: Ref<string>;
+                                childrenColumnName: Ref<string>;
+                                checkStrictly: Ref<boolean>;
+                                expandRows: Ref<any[]>;
+                                defaultExpandAll: Ref<boolean>;
+                                tableSize: Ref<any>;
+                                rowKey: Ref<string | null>;
+                                data: Ref<any[]>;
+                                _data: Ref<any[]>;
+                                isComplex: Ref<boolean>;
+                                _columns: Ref< TableColumnCtx<any>[]>;
+                                originColumns: Ref< TableColumnCtx<any>[]>;
+                                columns: Ref< TableColumnCtx<any>[]>;
+                                fixedColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                                leafColumns: Ref< TableColumnCtx<any>[]>;
+                                fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                updateOrderFns: (() => void)[];
+                                leafColumnsLength: Ref<number>;
+                                fixedLeafColumnsLength: Ref<number>;
+                                rightFixedLeafColumnsLength: Ref<number>;
+                                isAllSelected: Ref<boolean>;
+                                selection: Ref<any[]>;
+                                reserveSelection: Ref<boolean>;
+                                selectOnIndeterminate: Ref<boolean>;
+                                selectable: Ref<((row: any, index: number) => boolean) | null>;
+                                filters: Ref<StoreFilter>;
+                                filteredData: Ref<any[] | null>;
+                                sortingColumn: Ref< TableColumnCtx<any> | null>;
+                                sortProp: Ref<string | null>;
+                                sortOrder: Ref<string | number | null>;
+                                hoverRow: Ref<any>;
+                            }, options: Sort): void;
+                            filterChange(_states: {
+                                _currentRowKey: Ref<string | null>;
+                                currentRow: Ref<any>;
+                                expandRowKeys: Ref<(string | number)[]>;
+                                treeData: Ref<Record<string, TreeData>>;
+                                indent: Ref<number>;
+                                lazy: Ref<boolean>;
+                                lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                                lazyColumnIdentifier: Ref<string>;
+                                childrenColumnName: Ref<string>;
+                                checkStrictly: Ref<boolean>;
+                                expandRows: Ref<any[]>;
+                                defaultExpandAll: Ref<boolean>;
+                                tableSize: Ref<any>;
+                                rowKey: Ref<string | null>;
+                                data: Ref<any[]>;
+                                _data: Ref<any[]>;
+                                isComplex: Ref<boolean>;
+                                _columns: Ref< TableColumnCtx<any>[]>;
+                                originColumns: Ref< TableColumnCtx<any>[]>;
+                                columns: Ref< TableColumnCtx<any>[]>;
+                                fixedColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                                leafColumns: Ref< TableColumnCtx<any>[]>;
+                                fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                updateOrderFns: (() => void)[];
+                                leafColumnsLength: Ref<number>;
+                                fixedLeafColumnsLength: Ref<number>;
+                                rightFixedLeafColumnsLength: Ref<number>;
+                                isAllSelected: Ref<boolean>;
+                                selection: Ref<any[]>;
+                                reserveSelection: Ref<boolean>;
+                                selectOnIndeterminate: Ref<boolean>;
+                                selectable: Ref<((row: any, index: number) => boolean) | null>;
+                                filters: Ref<StoreFilter>;
+                                filteredData: Ref<any[] | null>;
+                                sortingColumn: Ref< TableColumnCtx<any> | null>;
+                                sortProp: Ref<string | null>;
+                                sortOrder: Ref<string | number | null>;
+                                hoverRow: Ref<any>;
+                            }, options: Filter<any>): void;
+                            toggleAllSelection(): void;
+                            rowSelectedChanged(_states: {
+                                _currentRowKey: Ref<string | null>;
+                                currentRow: Ref<any>;
+                                expandRowKeys: Ref<(string | number)[]>;
+                                treeData: Ref<Record<string, TreeData>>;
+                                indent: Ref<number>;
+                                lazy: Ref<boolean>;
+                                lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                                lazyColumnIdentifier: Ref<string>;
+                                childrenColumnName: Ref<string>;
+                                checkStrictly: Ref<boolean>;
+                                expandRows: Ref<any[]>;
+                                defaultExpandAll: Ref<boolean>;
+                                tableSize: Ref<any>;
+                                rowKey: Ref<string | null>;
+                                data: Ref<any[]>;
+                                _data: Ref<any[]>;
+                                isComplex: Ref<boolean>;
+                                _columns: Ref< TableColumnCtx<any>[]>;
+                                originColumns: Ref< TableColumnCtx<any>[]>;
+                                columns: Ref< TableColumnCtx<any>[]>;
+                                fixedColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                                leafColumns: Ref< TableColumnCtx<any>[]>;
+                                fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                updateOrderFns: (() => void)[];
+                                leafColumnsLength: Ref<number>;
+                                fixedLeafColumnsLength: Ref<number>;
+                                rightFixedLeafColumnsLength: Ref<number>;
+                                isAllSelected: Ref<boolean>;
+                                selection: Ref<any[]>;
+                                reserveSelection: Ref<boolean>;
+                                selectOnIndeterminate: Ref<boolean>;
+                                selectable: Ref<((row: any, index: number) => boolean) | null>;
+                                filters: Ref<StoreFilter>;
+                                filteredData: Ref<any[] | null>;
+                                sortingColumn: Ref< TableColumnCtx<any> | null>;
+                                sortProp: Ref<string | null>;
+                                sortOrder: Ref<string | number | null>;
+                                hoverRow: Ref<any>;
+                            }, row: any): void;
+                            setHoverRow(states: {
+                                _currentRowKey: Ref<string | null>;
+                                currentRow: Ref<any>;
+                                expandRowKeys: Ref<(string | number)[]>;
+                                treeData: Ref<Record<string, TreeData>>;
+                                indent: Ref<number>;
+                                lazy: Ref<boolean>;
+                                lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                                lazyColumnIdentifier: Ref<string>;
+                                childrenColumnName: Ref<string>;
+                                checkStrictly: Ref<boolean>;
+                                expandRows: Ref<any[]>;
+                                defaultExpandAll: Ref<boolean>;
+                                tableSize: Ref<any>;
+                                rowKey: Ref<string | null>;
+                                data: Ref<any[]>;
+                                _data: Ref<any[]>;
+                                isComplex: Ref<boolean>;
+                                _columns: Ref< TableColumnCtx<any>[]>;
+                                originColumns: Ref< TableColumnCtx<any>[]>;
+                                columns: Ref< TableColumnCtx<any>[]>;
+                                fixedColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                                leafColumns: Ref< TableColumnCtx<any>[]>;
+                                fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                updateOrderFns: (() => void)[];
+                                leafColumnsLength: Ref<number>;
+                                fixedLeafColumnsLength: Ref<number>;
+                                rightFixedLeafColumnsLength: Ref<number>;
+                                isAllSelected: Ref<boolean>;
+                                selection: Ref<any[]>;
+                                reserveSelection: Ref<boolean>;
+                                selectOnIndeterminate: Ref<boolean>;
+                                selectable: Ref<((row: any, index: number) => boolean) | null>;
+                                filters: Ref<StoreFilter>;
+                                filteredData: Ref<any[] | null>;
+                                sortingColumn: Ref< TableColumnCtx<any> | null>;
+                                sortProp: Ref<string | null>;
+                                sortOrder: Ref<string | number | null>;
+                                hoverRow: Ref<any>;
+                            }, row: any): void;
+                            setCurrentRow(_states: {
+                                _currentRowKey: Ref<string | null>;
+                                currentRow: Ref<any>;
+                                expandRowKeys: Ref<(string | number)[]>;
+                                treeData: Ref<Record<string, TreeData>>;
+                                indent: Ref<number>;
+                                lazy: Ref<boolean>;
+                                lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                                lazyColumnIdentifier: Ref<string>;
+                                childrenColumnName: Ref<string>;
+                                checkStrictly: Ref<boolean>;
+                                expandRows: Ref<any[]>;
+                                defaultExpandAll: Ref<boolean>;
+                                tableSize: Ref<any>;
+                                rowKey: Ref<string | null>;
+                                data: Ref<any[]>;
+                                _data: Ref<any[]>;
+                                isComplex: Ref<boolean>;
+                                _columns: Ref< TableColumnCtx<any>[]>;
+                                originColumns: Ref< TableColumnCtx<any>[]>;
+                                columns: Ref< TableColumnCtx<any>[]>;
+                                fixedColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                                leafColumns: Ref< TableColumnCtx<any>[]>;
+                                fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                                updateOrderFns: (() => void)[];
+                                leafColumnsLength: Ref<number>;
+                                fixedLeafColumnsLength: Ref<number>;
+                                rightFixedLeafColumnsLength: Ref<number>;
+                                isAllSelected: Ref<boolean>;
+                                selection: Ref<any[]>;
+                                reserveSelection: Ref<boolean>;
+                                selectOnIndeterminate: Ref<boolean>;
+                                selectable: Ref<((row: any, index: number) => boolean) | null>;
+                                filters: Ref<StoreFilter>;
+                                filteredData: Ref<any[] | null>;
+                                sortingColumn: Ref< TableColumnCtx<any> | null>;
+                                sortProp: Ref<string | null>;
+                                sortOrder: Ref<string | number | null>;
+                                hoverRow: Ref<any>;
+                            }, row: any): void;
+                        };
+                        commit: (name: "sort" | "setData" | "insertColumn" | "updateColumnOrder" | "removeColumn" | "changeSortCondition" | "filterChange" | "toggleAllSelection" | "rowSelectedChanged" | "setHoverRow" | "setCurrentRow", ...args: any[]) => void;
+                        updateTableScrollY: () => void;
+                        assertRowKey: () => void;
+                        updateColumns: () => void;
+                        scheduleLayout: (needUpdateColumns?: boolean, immediate?: boolean) => void;
+                        isSelected: (row: any) => boolean;
+                        clearSelection: () => void;
+                        cleanSelection: () => void;
+                        getSelectionRows: () => any[];
+                        toggleRowSelection: (row: any, selected?: boolean, emitChange?: boolean, ignoreSelectable?: boolean) => void;
+                        _toggleAllSelection: () => void;
+                        toggleAllSelection: (() => void) | null;
+                        updateAllSelected: () => void;
+                        updateFilters: (column: TableColumnCtx<any>, values: string[]) => Record<string, string[]>;
+                        updateCurrentRow: (_currentRow: any) => void;
+                        updateSort: (column: TableColumnCtx<any> | null, prop: string | null, order: TableSortOrder | null) => void;
+                        execFilter: () => void;
+                        execSort: () => void;
+                        execQuery: (ignore?: {
+                            filter: boolean;
+                        } | undefined) => void;
+                        clearFilter: (columnKeys?: string[] | string) => void;
+                        clearSort: () => void;
+                        toggleRowExpansion: (row: any, expanded?: boolean) => void;
+                        setExpandRowKeysAdapter: (val: (string | number)[]) => void;
+                        setCurrentRowKey: (key: string) => void;
+                        toggleRowExpansionAdapter: (row: any, expanded?: boolean) => void;
+                        isRowExpanded: (row: any) => boolean;
+                        updateExpandRows: () => void;
+                        updateCurrentRowData: () => void;
+                        loadOrToggle: (row: any) => void;
+                        updateTreeData: (ifChangeExpandRowKeys?: boolean, ifExpandAll?: boolean) => void;
+                        updateKeyChildren: (key: string, data: any[]) => void;
+                        states: {
+                            _currentRowKey: Ref<string | null>;
+                            currentRow: Ref<any>;
+                            expandRowKeys: Ref<(string | number)[]>;
+                            treeData: Ref<Record<string, TreeData>>;
+                            indent: Ref<number>;
+                            lazy: Ref<boolean>;
+                            lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                            lazyColumnIdentifier: Ref<string>;
+                            childrenColumnName: Ref<string>;
+                            checkStrictly: Ref<boolean>;
+                            expandRows: Ref<any[]>;
+                            defaultExpandAll: Ref<boolean>;
+                            tableSize: Ref<any>;
+                            rowKey: Ref<string | null>;
+                            data: Ref<any[]>;
+                            _data: Ref<any[]>;
+                            isComplex: Ref<boolean>;
+                            _columns: Ref< TableColumnCtx<any>[]>;
+                            originColumns: Ref< TableColumnCtx<any>[]>;
+                            columns: Ref< TableColumnCtx<any>[]>;
+                            fixedColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                            leafColumns: Ref< TableColumnCtx<any>[]>;
+                            fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            updateOrderFns: (() => void)[];
+                            leafColumnsLength: Ref<number>;
+                            fixedLeafColumnsLength: Ref<number>;
+                            rightFixedLeafColumnsLength: Ref<number>;
+                            isAllSelected: Ref<boolean>;
+                            selection: Ref<any[]>;
+                            reserveSelection: Ref<boolean>;
+                            selectOnIndeterminate: Ref<boolean>;
+                            selectable: Ref<((row: any, index: number) => boolean) | null>;
+                            filters: Ref<StoreFilter>;
+                            filteredData: Ref<any[] | null>;
+                            sortingColumn: Ref< TableColumnCtx<any> | null>;
+                            sortProp: Ref<string | null>;
+                            sortOrder: Ref<string | number | null>;
+                            hoverRow: Ref<any>;
+                        };
+                        ns: {
+                            namespace: ComputedRef<string>;
+                            b: (blockSuffix?: string) => string;
+                            e: (element?: string) => string;
+                            m: (modifier?: string) => string;
+                            be: (blockSuffix?: string, element?: string) => string;
+                            em: (element?: string, modifier?: string) => string;
+                            bm: (blockSuffix?: string, modifier?: string) => string;
+                            bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+                            is: {
+                                (name: string, state: boolean | undefined): string;
+                                (name: string): string;
+                            };
+                            cssVar: (object: Record<string, string>) => Record<string, string>;
+                            cssVarName: (name: string) => string;
+                            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                            cssVarBlockName: (name: string) => string;
+                        };
+                    };
+                    columns: ComputedRef< TableColumnCtx<any>[]>;
+                    handleHeaderFooterMousewheel: (_event: WheelEvent, data: any) => void;
+                    handleMouseLeave: () => void;
+                    tableId: string;
+                    tableSize: ComputedRef<"" | "small" | "default" | "large">;
+                    isHidden: Ref<boolean>;
+                    isEmpty: ComputedRef<boolean>;
+                    renderExpanded: Ref< RenderExpanded<any> | null>;
+                    resizeProxyVisible: Ref<boolean>;
+                    resizeState: Ref<{
+                        width: null | number;
+                        height: null | number;
+                        headerHeight: null | number;
+                    }>;
+                    isGroup: Ref<boolean>;
+                    bodyWidth: ComputedRef<string>;
+                    tableBodyStyles: ComputedRef<{
+                        width: string;
+                    }>;
+                    emptyBlockStyle: ComputedRef<{
+                        width: string;
+                        height: string;
+                    } | undefined>;
+                    debouncedUpdateLayout: DebouncedFunc<() => void>;
+                    setCurrentRow: (row: any) => void;
+                    getSelectionRows: () => any[];
+                    toggleRowSelection: (row: any, selected?: boolean, ignoreSelectable?: boolean) => void;
+                    clearSelection: () => void;
+                    clearFilter: (columnKeys?: string[] | string) => void;
+                    toggleAllSelection: () => void;
+                    toggleRowExpansion: (row: any, expanded?: boolean) => void;
+                    clearSort: () => void;
+                    doLayout: () => void;
+                    sort: (prop: string, order: string) => void;
+                    updateKeyChildren: (key: string, data: any[]) => void;
+                    t: Translator;
+                    setDragVisible: (visible: boolean) => void;
+                    context: Table<any>;
+                    computedSumText: ComputedRef<string>;
+                    computedEmptyText: ComputedRef<string>;
+                    tableLayout: ComputedRef<("fixed" | "auto") | undefined>;
+                    scrollbarViewStyle: {
+                        display: string;
+                        verticalAlign: string;
+                    };
+                    scrollbarStyle: ComputedRef<{
+                        height: string;
+                        maxHeight?: undefined;
+                    } | {
+                        maxHeight: string;
+                        height?: undefined;
+                    } | {
+                        height?: undefined;
+                        maxHeight?: undefined;
+                    }>;
+                    scrollBarRef: Ref<any>;
+                    scrollTo: (options: ScrollToOptions | number, yCoord?: number) => void;
+                    setScrollLeft: (left?: number) => void;
+                    setScrollTop: (top?: number) => void;
+                    allowDragLastColumn: boolean;
+                }, {}, {}, {}, {
+                    data: any[];
+                    style: CSSProperties;
+                    tableLayout: "fixed" | "auto";
+                    border: boolean;
+                    className: string;
+                    fit: boolean;
+                    lazy: boolean;
+                    scrollbarAlwaysOn: boolean;
+                    allowDragLastColumn: boolean;
+                    treeProps: TreeProps | undefined;
+                    defaultExpandAll: boolean;
+                    selectOnIndeterminate: boolean;
+                    indent: number;
+                    stripe: boolean;
+                    showHeader: boolean;
+                    showSummary: boolean;
+                    highlightCurrentRow: boolean;
+                    flexible: boolean;
+                    scrollbarTabindex: string | number;
+                    preserveExpandedContent: boolean;
+                }> | null;
+            };
+            $slots: Readonly<{
+                [name: string]: Slot<any> | undefined;
+            }>;
+            $root: ComponentPublicInstance | null;
+            $parent: ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: HTMLDivElement;
+            $options: ComponentOptionsBase<Readonly< ExtractPropTypes<{
+                defaultSort: {
+                    type: () => DefaultSort;
+                    default(): {};
+                };
+                height: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default(): string;
+                };
+                loading: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                adaptive: BooleanConstructor;
+                list: {
+                    type: {
+                        (arrayLength: number): ListObj[];
+                        (...items: ListObj[]): ListObj[];
+                        new (arrayLength: number): ListObj[];
+                        new (...items: ListObj[]): ListObj[];
+                        isArray(arg: any): arg is any[];
+                        readonly prototype: any[];
+                        from<T>(arrayLike: ArrayLike<T>): T[];
+                        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        of<T>(...items: T[]): T[];
+                        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                        readonly [Symbol.species]: ArrayConstructor;
+                    };
+                    default(): never[];
+                };
+                value: {
+                    type: {
+                        (arrayLength: number): ObjAny[];
+                        (...items: ObjAny[]): ObjAny[];
+                        new (arrayLength: number): ObjAny[];
+                        new (...items: ObjAny[]): ObjAny[];
+                        isArray(arg: any): arg is any[];
+                        readonly prototype: any[];
+                        from<T>(arrayLike: ArrayLike<T>): T[];
+                        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        of<T>(...items: T[]): T[];
+                        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                        readonly [Symbol.species]: ArrayConstructor;
+                    };
+                    default(): never[];
+                };
+                lineHeight: {
+                    type: (NumberConstructor | StringConstructor)[];
+                };
+                options: {
+                    type: ObjectConstructor;
+                    default(): {};
+                };
+                compons: {
+                    type: () => {
+                        [key: string]: Component;
+                    };
+                    default(): {};
+                };
+            }>> & Readonly<{}>, {
+                clearSelection: () => void;
+                toggleRowSelection: (...arr: any[]) => void;
+            }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
+                value: ObjAny[];
+                list: ListObj[];
+                loading: boolean;
+                options: Record<string, any>;
+                height: string | number;
+                compons: {
+                    [key: string]: Component;
+                };
+                defaultSort: DefaultSort;
+                adaptive: boolean;
+            }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+        } & Readonly<{
+            value: ObjAny[];
+            list: ListObj[];
+            loading: boolean;
+            options: Record<string, any>;
+            height: string | number;
+            compons: {
+                [key: string]: Component;
+            };
+            defaultSort: DefaultSort;
+            adaptive: boolean;
+        }> & Omit<Readonly< ExtractPropTypes<{
+            defaultSort: {
+                type: () => DefaultSort;
+                default(): {};
+            };
+            height: {
+                type: (NumberConstructor | StringConstructor)[];
+                default(): string;
+            };
+            loading: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            adaptive: BooleanConstructor;
+            list: {
+                type: {
+                    (arrayLength: number): ListObj[];
+                    (...items: ListObj[]): ListObj[];
+                    new (arrayLength: number): ListObj[];
+                    new (...items: ListObj[]): ListObj[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                    fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                default(): never[];
+            };
+            value: {
+                type: {
+                    (arrayLength: number): ObjAny[];
+                    (...items: ObjAny[]): ObjAny[];
+                    new (arrayLength: number): ObjAny[];
+                    new (...items: ObjAny[]): ObjAny[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                    fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                default(): never[];
+            };
+            lineHeight: {
+                type: (NumberConstructor | StringConstructor)[];
+            };
+            options: {
+                type: ObjectConstructor;
+                default(): {};
+            };
+            compons: {
+                type: () => {
+                    [key: string]: Component;
+                };
+                default(): {};
+            };
+        }>> & Readonly<{}>, "toggleRowSelection" | "clearSelection" | ("value" | "list" | "loading" | "options" | "height" | "compons" | "defaultSort" | "adaptive")> & ShallowUnwrapRef<{
+            clearSelection: () => void;
+            toggleRowSelection: (...arr: any[]) => void;
+        }> & {} & ComponentCustomProperties & {} & {
+            $slots: Partial<Record<string, (_: any) => any>> & {
+                'no-data'?(_: {}): any;
+            };
+        }) | null;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<ExtractPropTypes<{
+    configs: {
+        type: () => Config;
+    };
+    config: {
+        type: () => TableConfig;
+        default(): {};
+    };
+    list: {
+        type: {
+            (arrayLength: number): ListObj[];
+            (...items: ListObj[]): ListObj[];
+            new (arrayLength: number): ListObj[];
+            new (...items: ListObj[]): ListObj[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default(): never[];
+    };
+    load: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    options: {
+        type: ObjectConstructor;
+        default(): {};
+    };
+    compons: {
+        type: () => {
+            [key: string]: Component;
+        };
+        default(): {};
+    };
+    value: {
+        type: () => ObjAny;
+    };
+    ajax: {
+        type: (FunctionConstructor | StringConstructor)[];
+    };
+    param: {
+        type: ObjectConstructor;
+        default(): {};
+    };
+    ajaxConfig: {
+        type: ObjectConstructor;
+    };
+    onRequestAfter: {
+        type: FunctionConstructor;
+    };
+    onRequestBefore: {
+        type: FunctionConstructor;
+    };
+}>, {
+    getSelection: typeof globalThis.getSelection;
+    initData: (callback?: () => void) => void;
+    getList: (p?: ObjAny, callback?: (d?: ObjAny) => void) => void;
+    empty: () => void;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    configs: {
+        type: () => Config;
+    };
+    config: {
+        type: () => TableConfig;
+        default(): {};
+    };
+    list: {
+        type: {
+            (arrayLength: number): ListObj[];
+            (...items: ListObj[]): ListObj[];
+            new (arrayLength: number): ListObj[];
+            new (...items: ListObj[]): ListObj[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default(): never[];
+    };
+    load: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    options: {
+        type: ObjectConstructor;
+        default(): {};
+    };
+    compons: {
+        type: () => {
+            [key: string]: Component;
+        };
+        default(): {};
+    };
+    value: {
+        type: () => ObjAny;
+    };
+    ajax: {
+        type: (FunctionConstructor | StringConstructor)[];
+    };
+    param: {
+        type: ObjectConstructor;
+        default(): {};
+    };
+    ajaxConfig: {
+        type: ObjectConstructor;
+    };
+    onRequestAfter: {
+        type: FunctionConstructor;
+    };
+    onRequestBefore: {
+        type: FunctionConstructor;
+    };
+}>> & Readonly<{}>, {
+    config: TableConfig;
+    param: Record<string, any>;
+    list: ListObj[];
+    options: Record<string, any>;
+    load: boolean;
+    compons: {
+        [key: string]: Component;
+    };
+}, {}, {}, {}, string, ComponentProvideOptions, true, {
+    refTable: ({
+        $: ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            value: ObjAny[];
+            list: ListObj[];
+            loading: boolean;
+            options: Record<string, any>;
+            height: string | number;
+            compons: {
+                [key: string]: Component;
+            };
+            defaultSort: DefaultSort;
+            adaptive: boolean;
+        }> & Omit<{
+            readonly value: ObjAny[];
+            readonly list: ListObj[];
+            readonly loading: boolean;
+            readonly options: Record<string, any>;
+            readonly height: string | number;
+            readonly compons: {
+                [key: string]: Component;
+            };
+            readonly defaultSort: DefaultSort;
+            readonly adaptive: boolean;
+            readonly lineHeight?: string | number | undefined;
+        } & VNodeProps & AllowedComponentProps & ComponentCustomProps, "value" | "list" | "loading" | "options" | "height" | "compons" | "defaultSort" | "adaptive">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            tableRef: CreateComponentPublicInstanceWithMixins<Readonly< ExtractPropTypes<{
+                data: {
+                    type: PropType<any[]>;
+                    default: () => never[];
+                };
+                size: {
+                    readonly type: PropType<EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                width: (NumberConstructor | StringConstructor)[];
+                height: (NumberConstructor | StringConstructor)[];
+                maxHeight: (NumberConstructor | StringConstructor)[];
+                fit: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                stripe: BooleanConstructor;
+                border: BooleanConstructor;
+                rowKey: PropType< TableProps<any>["rowKey"]>;
+                showHeader: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                showSummary: BooleanConstructor;
+                sumText: StringConstructor;
+                summaryMethod: PropType< TableProps<any>["summaryMethod"]>;
+                rowClassName: PropType< TableProps<any>["rowClassName"]>;
+                rowStyle: PropType< TableProps<any>["rowStyle"]>;
+                cellClassName: PropType< TableProps<any>["cellClassName"]>;
+                cellStyle: PropType< TableProps<any>["cellStyle"]>;
+                headerRowClassName: PropType< TableProps<any>["headerRowClassName"]>;
+                headerRowStyle: PropType< TableProps<any>["headerRowStyle"]>;
+                headerCellClassName: PropType< TableProps<any>["headerCellClassName"]>;
+                headerCellStyle: PropType< TableProps<any>["headerCellStyle"]>;
+                highlightCurrentRow: BooleanConstructor;
+                currentRowKey: (NumberConstructor | StringConstructor)[];
+                emptyText: StringConstructor;
+                expandRowKeys: PropType< TableProps<any>["expandRowKeys"]>;
+                defaultExpandAll: BooleanConstructor;
+                defaultSort: PropType< TableProps<any>["defaultSort"]>;
+                tooltipEffect: StringConstructor;
+                tooltipOptions: PropType< TableProps<any>["tooltipOptions"]>;
+                spanMethod: PropType< TableProps<any>["spanMethod"]>;
+                selectOnIndeterminate: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                indent: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                treeProps: {
+                    type: PropType< TableProps<any>["treeProps"]>;
+                    default: () => {
+                        hasChildren: string;
+                        children: string;
+                        checkStrictly: boolean;
+                    };
+                };
+                lazy: BooleanConstructor;
+                load: PropType< TableProps<any>["load"]>;
+                style: {
+                    type: PropType<CSSProperties>;
+                    default: () => {};
+                };
+                className: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                tableLayout: {
+                    type: PropType<"fixed" | "auto">;
+                    default: string;
+                };
+                scrollbarAlwaysOn: BooleanConstructor;
+                flexible: BooleanConstructor;
+                showOverflowTooltip: PropType< TableProps<any>["showOverflowTooltip"]>;
+                tooltipFormatter: PropType< TableProps<any>["tooltipFormatter"]>;
+                appendFilterPanelTo: StringConstructor;
+                scrollbarTabindex: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                allowDragLastColumn: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                preserveExpandedContent: BooleanConstructor;
+            }>> & {
+                onScroll?: ((...args: any[]) => any) | undefined;
+                onSelect?: ((...args: any[]) => any) | undefined;
+                "onExpand-change"?: ((...args: any[]) => any) | undefined;
+                "onCurrent-change"?: ((...args: any[]) => any) | undefined;
+                "onSelect-all"?: ((...args: any[]) => any) | undefined;
+                "onHeader-click"?: ((...args: any[]) => any) | undefined;
+                "onHeader-contextmenu"?: ((...args: any[]) => any) | undefined;
+                "onHeader-dragend"?: ((...args: any[]) => any) | undefined;
+                "onSelection-change"?: ((...args: any[]) => any) | undefined;
+                "onSort-change"?: ((...args: any[]) => any) | undefined;
+                "onFilter-change"?: ((...args: any[]) => any) | undefined;
+                "onCell-mouse-enter"?: ((...args: any[]) => any) | undefined;
+                "onCell-mouse-leave"?: ((...args: any[]) => any) | undefined;
+                "onCell-contextmenu"?: ((...args: any[]) => any) | undefined;
+                "onCell-click"?: ((...args: any[]) => any) | undefined;
+                "onCell-dblclick"?: ((...args: any[]) => any) | undefined;
+                "onRow-click"?: ((...args: any[]) => any) | undefined;
+                "onRow-contextmenu"?: ((...args: any[]) => any) | undefined;
+                "onRow-dblclick"?: ((...args: any[]) => any) | undefined;
+            }, {
+                ns: {
+                    namespace: ComputedRef<string>;
+                    b: (blockSuffix?: string) => string;
+                    e: (element?: string) => string;
+                    m: (modifier?: string) => string;
+                    be: (blockSuffix?: string, element?: string) => string;
+                    em: (element?: string, modifier?: string) => string;
+                    bm: (blockSuffix?: string, modifier?: string) => string;
+                    bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+                    is: {
+                        (name: string, state: boolean | undefined): string;
+                        (name: string): string;
+                    };
+                    cssVar: (object: Record<string, string>) => Record<string, string>;
+                    cssVarName: (name: string) => string;
+                    cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                    cssVarBlockName: (name: string) => string;
+                };
+                layout: __DTS_DEFAULT_0__<any>;
+                store: {
+                    mutations: {
+                        setData(states: {
+                            _currentRowKey: Ref<string | null>;
+                            currentRow: Ref<any>;
+                            expandRowKeys: Ref<(string | number)[]>;
+                            treeData: Ref<Record<string, TreeData>>;
+                            indent: Ref<number>;
+                            lazy: Ref<boolean>;
+                            lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                            lazyColumnIdentifier: Ref<string>;
+                            childrenColumnName: Ref<string>;
+                            checkStrictly: Ref<boolean>;
+                            expandRows: Ref<any[]>;
+                            defaultExpandAll: Ref<boolean>;
+                            tableSize: Ref<any>;
+                            rowKey: Ref<string | null>;
+                            data: Ref<any[]>;
+                            _data: Ref<any[]>;
+                            isComplex: Ref<boolean>;
+                            _columns: Ref< TableColumnCtx<any>[]>;
+                            originColumns: Ref< TableColumnCtx<any>[]>;
+                            columns: Ref< TableColumnCtx<any>[]>;
+                            fixedColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                            leafColumns: Ref< TableColumnCtx<any>[]>;
+                            fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            updateOrderFns: (() => void)[];
+                            leafColumnsLength: Ref<number>;
+                            fixedLeafColumnsLength: Ref<number>;
+                            rightFixedLeafColumnsLength: Ref<number>;
+                            isAllSelected: Ref<boolean>;
+                            selection: Ref<any[]>;
+                            reserveSelection: Ref<boolean>;
+                            selectOnIndeterminate: Ref<boolean>;
+                            selectable: Ref<((row: any, index: number) => boolean) | null>;
+                            filters: Ref<StoreFilter>;
+                            filteredData: Ref<any[] | null>;
+                            sortingColumn: Ref< TableColumnCtx<any> | null>;
+                            sortProp: Ref<string | null>;
+                            sortOrder: Ref<string | number | null>;
+                            hoverRow: Ref<any>;
+                        }, data: any[]): void;
+                        insertColumn(states: {
+                            _currentRowKey: Ref<string | null>;
+                            currentRow: Ref<any>;
+                            expandRowKeys: Ref<(string | number)[]>;
+                            treeData: Ref<Record<string, TreeData>>;
+                            indent: Ref<number>;
+                            lazy: Ref<boolean>;
+                            lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                            lazyColumnIdentifier: Ref<string>;
+                            childrenColumnName: Ref<string>;
+                            checkStrictly: Ref<boolean>;
+                            expandRows: Ref<any[]>;
+                            defaultExpandAll: Ref<boolean>;
+                            tableSize: Ref<any>;
+                            rowKey: Ref<string | null>;
+                            data: Ref<any[]>;
+                            _data: Ref<any[]>;
+                            isComplex: Ref<boolean>;
+                            _columns: Ref< TableColumnCtx<any>[]>;
+                            originColumns: Ref< TableColumnCtx<any>[]>;
+                            columns: Ref< TableColumnCtx<any>[]>;
+                            fixedColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                            leafColumns: Ref< TableColumnCtx<any>[]>;
+                            fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            updateOrderFns: (() => void)[];
+                            leafColumnsLength: Ref<number>;
+                            fixedLeafColumnsLength: Ref<number>;
+                            rightFixedLeafColumnsLength: Ref<number>;
+                            isAllSelected: Ref<boolean>;
+                            selection: Ref<any[]>;
+                            reserveSelection: Ref<boolean>;
+                            selectOnIndeterminate: Ref<boolean>;
+                            selectable: Ref<((row: any, index: number) => boolean) | null>;
+                            filters: Ref<StoreFilter>;
+                            filteredData: Ref<any[] | null>;
+                            sortingColumn: Ref< TableColumnCtx<any> | null>;
+                            sortProp: Ref<string | null>;
+                            sortOrder: Ref<string | number | null>;
+                            hoverRow: Ref<any>;
+                        }, column: TableColumnCtx<any>, parent: TableColumnCtx<any>, updateColumnOrder: () => void): void;
+                        updateColumnOrder(states: {
+                            _currentRowKey: Ref<string | null>;
+                            currentRow: Ref<any>;
+                            expandRowKeys: Ref<(string | number)[]>;
+                            treeData: Ref<Record<string, TreeData>>;
+                            indent: Ref<number>;
+                            lazy: Ref<boolean>;
+                            lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                            lazyColumnIdentifier: Ref<string>;
+                            childrenColumnName: Ref<string>;
+                            checkStrictly: Ref<boolean>;
+                            expandRows: Ref<any[]>;
+                            defaultExpandAll: Ref<boolean>;
+                            tableSize: Ref<any>;
+                            rowKey: Ref<string | null>;
+                            data: Ref<any[]>;
+                            _data: Ref<any[]>;
+                            isComplex: Ref<boolean>;
+                            _columns: Ref< TableColumnCtx<any>[]>;
+                            originColumns: Ref< TableColumnCtx<any>[]>;
+                            columns: Ref< TableColumnCtx<any>[]>;
+                            fixedColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                            leafColumns: Ref< TableColumnCtx<any>[]>;
+                            fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            updateOrderFns: (() => void)[];
+                            leafColumnsLength: Ref<number>;
+                            fixedLeafColumnsLength: Ref<number>;
+                            rightFixedLeafColumnsLength: Ref<number>;
+                            isAllSelected: Ref<boolean>;
+                            selection: Ref<any[]>;
+                            reserveSelection: Ref<boolean>;
+                            selectOnIndeterminate: Ref<boolean>;
+                            selectable: Ref<((row: any, index: number) => boolean) | null>;
+                            filters: Ref<StoreFilter>;
+                            filteredData: Ref<any[] | null>;
+                            sortingColumn: Ref< TableColumnCtx<any> | null>;
+                            sortProp: Ref<string | null>;
+                            sortOrder: Ref<string | number | null>;
+                            hoverRow: Ref<any>;
+                        }, column: TableColumnCtx<any>): void;
+                        removeColumn(states: {
+                            _currentRowKey: Ref<string | null>;
+                            currentRow: Ref<any>;
+                            expandRowKeys: Ref<(string | number)[]>;
+                            treeData: Ref<Record<string, TreeData>>;
+                            indent: Ref<number>;
+                            lazy: Ref<boolean>;
+                            lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                            lazyColumnIdentifier: Ref<string>;
+                            childrenColumnName: Ref<string>;
+                            checkStrictly: Ref<boolean>;
+                            expandRows: Ref<any[]>;
+                            defaultExpandAll: Ref<boolean>;
+                            tableSize: Ref<any>;
+                            rowKey: Ref<string | null>;
+                            data: Ref<any[]>;
+                            _data: Ref<any[]>;
+                            isComplex: Ref<boolean>;
+                            _columns: Ref< TableColumnCtx<any>[]>;
+                            originColumns: Ref< TableColumnCtx<any>[]>;
+                            columns: Ref< TableColumnCtx<any>[]>;
+                            fixedColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                            leafColumns: Ref< TableColumnCtx<any>[]>;
+                            fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            updateOrderFns: (() => void)[];
+                            leafColumnsLength: Ref<number>;
+                            fixedLeafColumnsLength: Ref<number>;
+                            rightFixedLeafColumnsLength: Ref<number>;
+                            isAllSelected: Ref<boolean>;
+                            selection: Ref<any[]>;
+                            reserveSelection: Ref<boolean>;
+                            selectOnIndeterminate: Ref<boolean>;
+                            selectable: Ref<((row: any, index: number) => boolean) | null>;
+                            filters: Ref<StoreFilter>;
+                            filteredData: Ref<any[] | null>;
+                            sortingColumn: Ref< TableColumnCtx<any> | null>;
+                            sortProp: Ref<string | null>;
+                            sortOrder: Ref<string | number | null>;
+                            hoverRow: Ref<any>;
+                        }, column: TableColumnCtx<any>, parent: TableColumnCtx<any>, updateColumnOrder: () => void): void;
+                        sort(states: {
+                            _currentRowKey: Ref<string | null>;
+                            currentRow: Ref<any>;
+                            expandRowKeys: Ref<(string | number)[]>;
+                            treeData: Ref<Record<string, TreeData>>;
+                            indent: Ref<number>;
+                            lazy: Ref<boolean>;
+                            lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                            lazyColumnIdentifier: Ref<string>;
+                            childrenColumnName: Ref<string>;
+                            checkStrictly: Ref<boolean>;
+                            expandRows: Ref<any[]>;
+                            defaultExpandAll: Ref<boolean>;
+                            tableSize: Ref<any>;
+                            rowKey: Ref<string | null>;
+                            data: Ref<any[]>;
+                            _data: Ref<any[]>;
+                            isComplex: Ref<boolean>;
+                            _columns: Ref< TableColumnCtx<any>[]>;
+                            originColumns: Ref< TableColumnCtx<any>[]>;
+                            columns: Ref< TableColumnCtx<any>[]>;
+                            fixedColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                            leafColumns: Ref< TableColumnCtx<any>[]>;
+                            fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            updateOrderFns: (() => void)[];
+                            leafColumnsLength: Ref<number>;
+                            fixedLeafColumnsLength: Ref<number>;
+                            rightFixedLeafColumnsLength: Ref<number>;
+                            isAllSelected: Ref<boolean>;
+                            selection: Ref<any[]>;
+                            reserveSelection: Ref<boolean>;
+                            selectOnIndeterminate: Ref<boolean>;
+                            selectable: Ref<((row: any, index: number) => boolean) | null>;
+                            filters: Ref<StoreFilter>;
+                            filteredData: Ref<any[] | null>;
+                            sortingColumn: Ref< TableColumnCtx<any> | null>;
+                            sortProp: Ref<string | null>;
+                            sortOrder: Ref<string | number | null>;
+                            hoverRow: Ref<any>;
+                        }, options: Sort): void;
+                        changeSortCondition(states: {
+                            _currentRowKey: Ref<string | null>;
+                            currentRow: Ref<any>;
+                            expandRowKeys: Ref<(string | number)[]>;
+                            treeData: Ref<Record<string, TreeData>>;
+                            indent: Ref<number>;
+                            lazy: Ref<boolean>;
+                            lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                            lazyColumnIdentifier: Ref<string>;
+                            childrenColumnName: Ref<string>;
+                            checkStrictly: Ref<boolean>;
+                            expandRows: Ref<any[]>;
+                            defaultExpandAll: Ref<boolean>;
+                            tableSize: Ref<any>;
+                            rowKey: Ref<string | null>;
+                            data: Ref<any[]>;
+                            _data: Ref<any[]>;
+                            isComplex: Ref<boolean>;
+                            _columns: Ref< TableColumnCtx<any>[]>;
+                            originColumns: Ref< TableColumnCtx<any>[]>;
+                            columns: Ref< TableColumnCtx<any>[]>;
+                            fixedColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                            leafColumns: Ref< TableColumnCtx<any>[]>;
+                            fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            updateOrderFns: (() => void)[];
+                            leafColumnsLength: Ref<number>;
+                            fixedLeafColumnsLength: Ref<number>;
+                            rightFixedLeafColumnsLength: Ref<number>;
+                            isAllSelected: Ref<boolean>;
+                            selection: Ref<any[]>;
+                            reserveSelection: Ref<boolean>;
+                            selectOnIndeterminate: Ref<boolean>;
+                            selectable: Ref<((row: any, index: number) => boolean) | null>;
+                            filters: Ref<StoreFilter>;
+                            filteredData: Ref<any[] | null>;
+                            sortingColumn: Ref< TableColumnCtx<any> | null>;
+                            sortProp: Ref<string | null>;
+                            sortOrder: Ref<string | number | null>;
+                            hoverRow: Ref<any>;
+                        }, options: Sort): void;
+                        filterChange(_states: {
+                            _currentRowKey: Ref<string | null>;
+                            currentRow: Ref<any>;
+                            expandRowKeys: Ref<(string | number)[]>;
+                            treeData: Ref<Record<string, TreeData>>;
+                            indent: Ref<number>;
+                            lazy: Ref<boolean>;
+                            lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                            lazyColumnIdentifier: Ref<string>;
+                            childrenColumnName: Ref<string>;
+                            checkStrictly: Ref<boolean>;
+                            expandRows: Ref<any[]>;
+                            defaultExpandAll: Ref<boolean>;
+                            tableSize: Ref<any>;
+                            rowKey: Ref<string | null>;
+                            data: Ref<any[]>;
+                            _data: Ref<any[]>;
+                            isComplex: Ref<boolean>;
+                            _columns: Ref< TableColumnCtx<any>[]>;
+                            originColumns: Ref< TableColumnCtx<any>[]>;
+                            columns: Ref< TableColumnCtx<any>[]>;
+                            fixedColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                            leafColumns: Ref< TableColumnCtx<any>[]>;
+                            fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            updateOrderFns: (() => void)[];
+                            leafColumnsLength: Ref<number>;
+                            fixedLeafColumnsLength: Ref<number>;
+                            rightFixedLeafColumnsLength: Ref<number>;
+                            isAllSelected: Ref<boolean>;
+                            selection: Ref<any[]>;
+                            reserveSelection: Ref<boolean>;
+                            selectOnIndeterminate: Ref<boolean>;
+                            selectable: Ref<((row: any, index: number) => boolean) | null>;
+                            filters: Ref<StoreFilter>;
+                            filteredData: Ref<any[] | null>;
+                            sortingColumn: Ref< TableColumnCtx<any> | null>;
+                            sortProp: Ref<string | null>;
+                            sortOrder: Ref<string | number | null>;
+                            hoverRow: Ref<any>;
+                        }, options: Filter<any>): void;
+                        toggleAllSelection(): void;
+                        rowSelectedChanged(_states: {
+                            _currentRowKey: Ref<string | null>;
+                            currentRow: Ref<any>;
+                            expandRowKeys: Ref<(string | number)[]>;
+                            treeData: Ref<Record<string, TreeData>>;
+                            indent: Ref<number>;
+                            lazy: Ref<boolean>;
+                            lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                            lazyColumnIdentifier: Ref<string>;
+                            childrenColumnName: Ref<string>;
+                            checkStrictly: Ref<boolean>;
+                            expandRows: Ref<any[]>;
+                            defaultExpandAll: Ref<boolean>;
+                            tableSize: Ref<any>;
+                            rowKey: Ref<string | null>;
+                            data: Ref<any[]>;
+                            _data: Ref<any[]>;
+                            isComplex: Ref<boolean>;
+                            _columns: Ref< TableColumnCtx<any>[]>;
+                            originColumns: Ref< TableColumnCtx<any>[]>;
+                            columns: Ref< TableColumnCtx<any>[]>;
+                            fixedColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                            leafColumns: Ref< TableColumnCtx<any>[]>;
+                            fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            updateOrderFns: (() => void)[];
+                            leafColumnsLength: Ref<number>;
+                            fixedLeafColumnsLength: Ref<number>;
+                            rightFixedLeafColumnsLength: Ref<number>;
+                            isAllSelected: Ref<boolean>;
+                            selection: Ref<any[]>;
+                            reserveSelection: Ref<boolean>;
+                            selectOnIndeterminate: Ref<boolean>;
+                            selectable: Ref<((row: any, index: number) => boolean) | null>;
+                            filters: Ref<StoreFilter>;
+                            filteredData: Ref<any[] | null>;
+                            sortingColumn: Ref< TableColumnCtx<any> | null>;
+                            sortProp: Ref<string | null>;
+                            sortOrder: Ref<string | number | null>;
+                            hoverRow: Ref<any>;
+                        }, row: any): void;
+                        setHoverRow(states: {
+                            _currentRowKey: Ref<string | null>;
+                            currentRow: Ref<any>;
+                            expandRowKeys: Ref<(string | number)[]>;
+                            treeData: Ref<Record<string, TreeData>>;
+                            indent: Ref<number>;
+                            lazy: Ref<boolean>;
+                            lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                            lazyColumnIdentifier: Ref<string>;
+                            childrenColumnName: Ref<string>;
+                            checkStrictly: Ref<boolean>;
+                            expandRows: Ref<any[]>;
+                            defaultExpandAll: Ref<boolean>;
+                            tableSize: Ref<any>;
+                            rowKey: Ref<string | null>;
+                            data: Ref<any[]>;
+                            _data: Ref<any[]>;
+                            isComplex: Ref<boolean>;
+                            _columns: Ref< TableColumnCtx<any>[]>;
+                            originColumns: Ref< TableColumnCtx<any>[]>;
+                            columns: Ref< TableColumnCtx<any>[]>;
+                            fixedColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                            leafColumns: Ref< TableColumnCtx<any>[]>;
+                            fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            updateOrderFns: (() => void)[];
+                            leafColumnsLength: Ref<number>;
+                            fixedLeafColumnsLength: Ref<number>;
+                            rightFixedLeafColumnsLength: Ref<number>;
+                            isAllSelected: Ref<boolean>;
+                            selection: Ref<any[]>;
+                            reserveSelection: Ref<boolean>;
+                            selectOnIndeterminate: Ref<boolean>;
+                            selectable: Ref<((row: any, index: number) => boolean) | null>;
+                            filters: Ref<StoreFilter>;
+                            filteredData: Ref<any[] | null>;
+                            sortingColumn: Ref< TableColumnCtx<any> | null>;
+                            sortProp: Ref<string | null>;
+                            sortOrder: Ref<string | number | null>;
+                            hoverRow: Ref<any>;
+                        }, row: any): void;
+                        setCurrentRow(_states: {
+                            _currentRowKey: Ref<string | null>;
+                            currentRow: Ref<any>;
+                            expandRowKeys: Ref<(string | number)[]>;
+                            treeData: Ref<Record<string, TreeData>>;
+                            indent: Ref<number>;
+                            lazy: Ref<boolean>;
+                            lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                            lazyColumnIdentifier: Ref<string>;
+                            childrenColumnName: Ref<string>;
+                            checkStrictly: Ref<boolean>;
+                            expandRows: Ref<any[]>;
+                            defaultExpandAll: Ref<boolean>;
+                            tableSize: Ref<any>;
+                            rowKey: Ref<string | null>;
+                            data: Ref<any[]>;
+                            _data: Ref<any[]>;
+                            isComplex: Ref<boolean>;
+                            _columns: Ref< TableColumnCtx<any>[]>;
+                            originColumns: Ref< TableColumnCtx<any>[]>;
+                            columns: Ref< TableColumnCtx<any>[]>;
+                            fixedColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                            leafColumns: Ref< TableColumnCtx<any>[]>;
+                            fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            updateOrderFns: (() => void)[];
+                            leafColumnsLength: Ref<number>;
+                            fixedLeafColumnsLength: Ref<number>;
+                            rightFixedLeafColumnsLength: Ref<number>;
+                            isAllSelected: Ref<boolean>;
+                            selection: Ref<any[]>;
+                            reserveSelection: Ref<boolean>;
+                            selectOnIndeterminate: Ref<boolean>;
+                            selectable: Ref<((row: any, index: number) => boolean) | null>;
+                            filters: Ref<StoreFilter>;
+                            filteredData: Ref<any[] | null>;
+                            sortingColumn: Ref< TableColumnCtx<any> | null>;
+                            sortProp: Ref<string | null>;
+                            sortOrder: Ref<string | number | null>;
+                            hoverRow: Ref<any>;
+                        }, row: any): void;
+                    };
+                    commit: (name: "sort" | "setData" | "insertColumn" | "updateColumnOrder" | "removeColumn" | "changeSortCondition" | "filterChange" | "toggleAllSelection" | "rowSelectedChanged" | "setHoverRow" | "setCurrentRow", ...args: any[]) => void;
+                    updateTableScrollY: () => void;
+                    assertRowKey: () => void;
+                    updateColumns: () => void;
+                    scheduleLayout: (needUpdateColumns?: boolean, immediate?: boolean) => void;
+                    isSelected: (row: any) => boolean;
+                    clearSelection: () => void;
+                    cleanSelection: () => void;
+                    getSelectionRows: () => any[];
+                    toggleRowSelection: (row: any, selected?: boolean, emitChange?: boolean, ignoreSelectable?: boolean) => void;
+                    _toggleAllSelection: () => void;
+                    toggleAllSelection: (() => void) | null;
+                    updateAllSelected: () => void;
+                    updateFilters: (column: TableColumnCtx<any>, values: string[]) => Record<string, string[]>;
+                    updateCurrentRow: (_currentRow: any) => void;
+                    updateSort: (column: TableColumnCtx<any> | null, prop: string | null, order: TableSortOrder | null) => void;
+                    execFilter: () => void;
+                    execSort: () => void;
+                    execQuery: (ignore?: {
+                        filter: boolean;
+                    } | undefined) => void;
+                    clearFilter: (columnKeys?: string[] | string) => void;
+                    clearSort: () => void;
+                    toggleRowExpansion: (row: any, expanded?: boolean) => void;
+                    setExpandRowKeysAdapter: (val: (string | number)[]) => void;
+                    setCurrentRowKey: (key: string) => void;
+                    toggleRowExpansionAdapter: (row: any, expanded?: boolean) => void;
+                    isRowExpanded: (row: any) => boolean;
+                    updateExpandRows: () => void;
+                    updateCurrentRowData: () => void;
+                    loadOrToggle: (row: any) => void;
+                    updateTreeData: (ifChangeExpandRowKeys?: boolean, ifExpandAll?: boolean) => void;
+                    updateKeyChildren: (key: string, data: any[]) => void;
+                    states: {
+                        _currentRowKey: Ref<string | null>;
+                        currentRow: Ref<any>;
+                        expandRowKeys: Ref<(string | number)[]>;
+                        treeData: Ref<Record<string, TreeData>>;
+                        indent: Ref<number>;
+                        lazy: Ref<boolean>;
+                        lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                        lazyColumnIdentifier: Ref<string>;
+                        childrenColumnName: Ref<string>;
+                        checkStrictly: Ref<boolean>;
+                        expandRows: Ref<any[]>;
+                        defaultExpandAll: Ref<boolean>;
+                        tableSize: Ref<any>;
+                        rowKey: Ref<string | null>;
+                        data: Ref<any[]>;
+                        _data: Ref<any[]>;
+                        isComplex: Ref<boolean>;
+                        _columns: Ref< TableColumnCtx<any>[]>;
+                        originColumns: Ref< TableColumnCtx<any>[]>;
+                        columns: Ref< TableColumnCtx<any>[]>;
+                        fixedColumns: Ref< TableColumnCtx<any>[]>;
+                        rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                        leafColumns: Ref< TableColumnCtx<any>[]>;
+                        fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                        rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                        updateOrderFns: (() => void)[];
+                        leafColumnsLength: Ref<number>;
+                        fixedLeafColumnsLength: Ref<number>;
+                        rightFixedLeafColumnsLength: Ref<number>;
+                        isAllSelected: Ref<boolean>;
+                        selection: Ref<any[]>;
+                        reserveSelection: Ref<boolean>;
+                        selectOnIndeterminate: Ref<boolean>;
+                        selectable: Ref<((row: any, index: number) => boolean) | null>;
+                        filters: Ref<StoreFilter>;
+                        filteredData: Ref<any[] | null>;
+                        sortingColumn: Ref< TableColumnCtx<any> | null>;
+                        sortProp: Ref<string | null>;
+                        sortOrder: Ref<string | number | null>;
+                        hoverRow: Ref<any>;
+                    };
+                    ns: {
+                        namespace: ComputedRef<string>;
+                        b: (blockSuffix?: string) => string;
+                        e: (element?: string) => string;
+                        m: (modifier?: string) => string;
+                        be: (blockSuffix?: string, element?: string) => string;
+                        em: (element?: string, modifier?: string) => string;
+                        bm: (blockSuffix?: string, modifier?: string) => string;
+                        bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+                        is: {
+                            (name: string, state: boolean | undefined): string;
+                            (name: string): string;
+                        };
+                        cssVar: (object: Record<string, string>) => Record<string, string>;
+                        cssVarName: (name: string) => string;
+                        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                        cssVarBlockName: (name: string) => string;
+                    };
+                };
+                columns: ComputedRef< TableColumnCtx<any>[]>;
+                handleHeaderFooterMousewheel: (_event: WheelEvent, data: any) => void;
+                handleMouseLeave: () => void;
+                tableId: string;
+                tableSize: ComputedRef<"" | "small" | "default" | "large">;
+                isHidden: Ref<boolean>;
+                isEmpty: ComputedRef<boolean>;
+                renderExpanded: Ref< RenderExpanded<any> | null>;
+                resizeProxyVisible: Ref<boolean>;
+                resizeState: Ref<{
+                    width: null | number;
+                    height: null | number;
+                    headerHeight: null | number;
+                }>;
+                isGroup: Ref<boolean>;
+                bodyWidth: ComputedRef<string>;
+                tableBodyStyles: ComputedRef<{
+                    width: string;
+                }>;
+                emptyBlockStyle: ComputedRef<{
+                    width: string;
+                    height: string;
+                } | undefined>;
+                debouncedUpdateLayout: DebouncedFunc<() => void>;
+                setCurrentRow: (row: any) => void;
+                getSelectionRows: () => any[];
+                toggleRowSelection: (row: any, selected?: boolean, ignoreSelectable?: boolean) => void;
+                clearSelection: () => void;
+                clearFilter: (columnKeys?: string[] | string) => void;
+                toggleAllSelection: () => void;
+                toggleRowExpansion: (row: any, expanded?: boolean) => void;
+                clearSort: () => void;
+                doLayout: () => void;
+                sort: (prop: string, order: string) => void;
+                updateKeyChildren: (key: string, data: any[]) => void;
+                t: Translator;
+                setDragVisible: (visible: boolean) => void;
+                context: Table<any>;
+                computedSumText: ComputedRef<string>;
+                computedEmptyText: ComputedRef<string>;
+                tableLayout: ComputedRef<("fixed" | "auto") | undefined>;
+                scrollbarViewStyle: {
+                    display: string;
+                    verticalAlign: string;
+                };
+                scrollbarStyle: ComputedRef<{
+                    height: string;
+                    maxHeight?: undefined;
+                } | {
+                    maxHeight: string;
+                    height?: undefined;
+                } | {
+                    height?: undefined;
+                    maxHeight?: undefined;
+                }>;
+                scrollBarRef: Ref<any>;
+                scrollTo: (options: ScrollToOptions | number, yCoord?: number) => void;
+                setScrollLeft: (left?: number) => void;
+                setScrollTop: (top?: number) => void;
+                allowDragLastColumn: boolean;
+            }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("select" | "expand-change" | "scroll" | "sort-change" | "row-click" | "select-all" | "current-change" | "header-click" | "header-contextmenu" | "header-dragend" | "selection-change" | "filter-change" | "cell-mouse-enter" | "cell-mouse-leave" | "cell-contextmenu" | "cell-click" | "cell-dblclick" | "row-contextmenu" | "row-dblclick")[], VNodeProps & AllowedComponentProps & ComponentCustomProps, {
+                data: any[];
+                style: CSSProperties;
+                tableLayout: "fixed" | "auto";
+                border: boolean;
+                className: string;
+                fit: boolean;
+                lazy: boolean;
+                scrollbarAlwaysOn: boolean;
+                allowDragLastColumn: boolean;
+                treeProps: TreeProps | undefined;
+                defaultExpandAll: boolean;
+                selectOnIndeterminate: boolean;
+                indent: number;
+                stripe: boolean;
+                showHeader: boolean;
+                showSummary: boolean;
+                highlightCurrentRow: boolean;
+                flexible: boolean;
+                scrollbarTabindex: string | number;
+                preserveExpandedContent: boolean;
+            }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly< ExtractPropTypes<{
+                data: {
+                    type: PropType<any[]>;
+                    default: () => never[];
+                };
+                size: {
+                    readonly type: PropType<EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                width: (NumberConstructor | StringConstructor)[];
+                height: (NumberConstructor | StringConstructor)[];
+                maxHeight: (NumberConstructor | StringConstructor)[];
+                fit: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                stripe: BooleanConstructor;
+                border: BooleanConstructor;
+                rowKey: PropType< TableProps<any>["rowKey"]>;
+                showHeader: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                showSummary: BooleanConstructor;
+                sumText: StringConstructor;
+                summaryMethod: PropType< TableProps<any>["summaryMethod"]>;
+                rowClassName: PropType< TableProps<any>["rowClassName"]>;
+                rowStyle: PropType< TableProps<any>["rowStyle"]>;
+                cellClassName: PropType< TableProps<any>["cellClassName"]>;
+                cellStyle: PropType< TableProps<any>["cellStyle"]>;
+                headerRowClassName: PropType< TableProps<any>["headerRowClassName"]>;
+                headerRowStyle: PropType< TableProps<any>["headerRowStyle"]>;
+                headerCellClassName: PropType< TableProps<any>["headerCellClassName"]>;
+                headerCellStyle: PropType< TableProps<any>["headerCellStyle"]>;
+                highlightCurrentRow: BooleanConstructor;
+                currentRowKey: (NumberConstructor | StringConstructor)[];
+                emptyText: StringConstructor;
+                expandRowKeys: PropType< TableProps<any>["expandRowKeys"]>;
+                defaultExpandAll: BooleanConstructor;
+                defaultSort: PropType< TableProps<any>["defaultSort"]>;
+                tooltipEffect: StringConstructor;
+                tooltipOptions: PropType< TableProps<any>["tooltipOptions"]>;
+                spanMethod: PropType< TableProps<any>["spanMethod"]>;
+                selectOnIndeterminate: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                indent: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                treeProps: {
+                    type: PropType< TableProps<any>["treeProps"]>;
+                    default: () => {
+                        hasChildren: string;
+                        children: string;
+                        checkStrictly: boolean;
+                    };
+                };
+                lazy: BooleanConstructor;
+                load: PropType< TableProps<any>["load"]>;
+                style: {
+                    type: PropType<CSSProperties>;
+                    default: () => {};
+                };
+                className: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                tableLayout: {
+                    type: PropType<"fixed" | "auto">;
+                    default: string;
+                };
+                scrollbarAlwaysOn: BooleanConstructor;
+                flexible: BooleanConstructor;
+                showOverflowTooltip: PropType< TableProps<any>["showOverflowTooltip"]>;
+                tooltipFormatter: PropType< TableProps<any>["tooltipFormatter"]>;
+                appendFilterPanelTo: StringConstructor;
+                scrollbarTabindex: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                allowDragLastColumn: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                preserveExpandedContent: BooleanConstructor;
+            }>> & {
+                onScroll?: ((...args: any[]) => any) | undefined;
+                onSelect?: ((...args: any[]) => any) | undefined;
+                "onExpand-change"?: ((...args: any[]) => any) | undefined;
+                "onCurrent-change"?: ((...args: any[]) => any) | undefined;
+                "onSelect-all"?: ((...args: any[]) => any) | undefined;
+                "onHeader-click"?: ((...args: any[]) => any) | undefined;
+                "onHeader-contextmenu"?: ((...args: any[]) => any) | undefined;
+                "onHeader-dragend"?: ((...args: any[]) => any) | undefined;
+                "onSelection-change"?: ((...args: any[]) => any) | undefined;
+                "onSort-change"?: ((...args: any[]) => any) | undefined;
+                "onFilter-change"?: ((...args: any[]) => any) | undefined;
+                "onCell-mouse-enter"?: ((...args: any[]) => any) | undefined;
+                "onCell-mouse-leave"?: ((...args: any[]) => any) | undefined;
+                "onCell-contextmenu"?: ((...args: any[]) => any) | undefined;
+                "onCell-click"?: ((...args: any[]) => any) | undefined;
+                "onCell-dblclick"?: ((...args: any[]) => any) | undefined;
+                "onRow-click"?: ((...args: any[]) => any) | undefined;
+                "onRow-contextmenu"?: ((...args: any[]) => any) | undefined;
+                "onRow-dblclick"?: ((...args: any[]) => any) | undefined;
+            }, {
+                ns: {
+                    namespace: ComputedRef<string>;
+                    b: (blockSuffix?: string) => string;
+                    e: (element?: string) => string;
+                    m: (modifier?: string) => string;
+                    be: (blockSuffix?: string, element?: string) => string;
+                    em: (element?: string, modifier?: string) => string;
+                    bm: (blockSuffix?: string, modifier?: string) => string;
+                    bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+                    is: {
+                        (name: string, state: boolean | undefined): string;
+                        (name: string): string;
+                    };
+                    cssVar: (object: Record<string, string>) => Record<string, string>;
+                    cssVarName: (name: string) => string;
+                    cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                    cssVarBlockName: (name: string) => string;
+                };
+                layout: __DTS_DEFAULT_0__<any>;
+                store: {
+                    mutations: {
+                        setData(states: {
+                            _currentRowKey: Ref<string | null>;
+                            currentRow: Ref<any>;
+                            expandRowKeys: Ref<(string | number)[]>;
+                            treeData: Ref<Record<string, TreeData>>;
+                            indent: Ref<number>;
+                            lazy: Ref<boolean>;
+                            lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                            lazyColumnIdentifier: Ref<string>;
+                            childrenColumnName: Ref<string>;
+                            checkStrictly: Ref<boolean>;
+                            expandRows: Ref<any[]>;
+                            defaultExpandAll: Ref<boolean>;
+                            tableSize: Ref<any>;
+                            rowKey: Ref<string | null>;
+                            data: Ref<any[]>;
+                            _data: Ref<any[]>;
+                            isComplex: Ref<boolean>;
+                            _columns: Ref< TableColumnCtx<any>[]>;
+                            originColumns: Ref< TableColumnCtx<any>[]>;
+                            columns: Ref< TableColumnCtx<any>[]>;
+                            fixedColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                            leafColumns: Ref< TableColumnCtx<any>[]>;
+                            fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            updateOrderFns: (() => void)[];
+                            leafColumnsLength: Ref<number>;
+                            fixedLeafColumnsLength: Ref<number>;
+                            rightFixedLeafColumnsLength: Ref<number>;
+                            isAllSelected: Ref<boolean>;
+                            selection: Ref<any[]>;
+                            reserveSelection: Ref<boolean>;
+                            selectOnIndeterminate: Ref<boolean>;
+                            selectable: Ref<((row: any, index: number) => boolean) | null>;
+                            filters: Ref<StoreFilter>;
+                            filteredData: Ref<any[] | null>;
+                            sortingColumn: Ref< TableColumnCtx<any> | null>;
+                            sortProp: Ref<string | null>;
+                            sortOrder: Ref<string | number | null>;
+                            hoverRow: Ref<any>;
+                        }, data: any[]): void;
+                        insertColumn(states: {
+                            _currentRowKey: Ref<string | null>;
+                            currentRow: Ref<any>;
+                            expandRowKeys: Ref<(string | number)[]>;
+                            treeData: Ref<Record<string, TreeData>>;
+                            indent: Ref<number>;
+                            lazy: Ref<boolean>;
+                            lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                            lazyColumnIdentifier: Ref<string>;
+                            childrenColumnName: Ref<string>;
+                            checkStrictly: Ref<boolean>;
+                            expandRows: Ref<any[]>;
+                            defaultExpandAll: Ref<boolean>;
+                            tableSize: Ref<any>;
+                            rowKey: Ref<string | null>;
+                            data: Ref<any[]>;
+                            _data: Ref<any[]>;
+                            isComplex: Ref<boolean>;
+                            _columns: Ref< TableColumnCtx<any>[]>;
+                            originColumns: Ref< TableColumnCtx<any>[]>;
+                            columns: Ref< TableColumnCtx<any>[]>;
+                            fixedColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                            leafColumns: Ref< TableColumnCtx<any>[]>;
+                            fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            updateOrderFns: (() => void)[];
+                            leafColumnsLength: Ref<number>;
+                            fixedLeafColumnsLength: Ref<number>;
+                            rightFixedLeafColumnsLength: Ref<number>;
+                            isAllSelected: Ref<boolean>;
+                            selection: Ref<any[]>;
+                            reserveSelection: Ref<boolean>;
+                            selectOnIndeterminate: Ref<boolean>;
+                            selectable: Ref<((row: any, index: number) => boolean) | null>;
+                            filters: Ref<StoreFilter>;
+                            filteredData: Ref<any[] | null>;
+                            sortingColumn: Ref< TableColumnCtx<any> | null>;
+                            sortProp: Ref<string | null>;
+                            sortOrder: Ref<string | number | null>;
+                            hoverRow: Ref<any>;
+                        }, column: TableColumnCtx<any>, parent: TableColumnCtx<any>, updateColumnOrder: () => void): void;
+                        updateColumnOrder(states: {
+                            _currentRowKey: Ref<string | null>;
+                            currentRow: Ref<any>;
+                            expandRowKeys: Ref<(string | number)[]>;
+                            treeData: Ref<Record<string, TreeData>>;
+                            indent: Ref<number>;
+                            lazy: Ref<boolean>;
+                            lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                            lazyColumnIdentifier: Ref<string>;
+                            childrenColumnName: Ref<string>;
+                            checkStrictly: Ref<boolean>;
+                            expandRows: Ref<any[]>;
+                            defaultExpandAll: Ref<boolean>;
+                            tableSize: Ref<any>;
+                            rowKey: Ref<string | null>;
+                            data: Ref<any[]>;
+                            _data: Ref<any[]>;
+                            isComplex: Ref<boolean>;
+                            _columns: Ref< TableColumnCtx<any>[]>;
+                            originColumns: Ref< TableColumnCtx<any>[]>;
+                            columns: Ref< TableColumnCtx<any>[]>;
+                            fixedColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                            leafColumns: Ref< TableColumnCtx<any>[]>;
+                            fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            updateOrderFns: (() => void)[];
+                            leafColumnsLength: Ref<number>;
+                            fixedLeafColumnsLength: Ref<number>;
+                            rightFixedLeafColumnsLength: Ref<number>;
+                            isAllSelected: Ref<boolean>;
+                            selection: Ref<any[]>;
+                            reserveSelection: Ref<boolean>;
+                            selectOnIndeterminate: Ref<boolean>;
+                            selectable: Ref<((row: any, index: number) => boolean) | null>;
+                            filters: Ref<StoreFilter>;
+                            filteredData: Ref<any[] | null>;
+                            sortingColumn: Ref< TableColumnCtx<any> | null>;
+                            sortProp: Ref<string | null>;
+                            sortOrder: Ref<string | number | null>;
+                            hoverRow: Ref<any>;
+                        }, column: TableColumnCtx<any>): void;
+                        removeColumn(states: {
+                            _currentRowKey: Ref<string | null>;
+                            currentRow: Ref<any>;
+                            expandRowKeys: Ref<(string | number)[]>;
+                            treeData: Ref<Record<string, TreeData>>;
+                            indent: Ref<number>;
+                            lazy: Ref<boolean>;
+                            lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                            lazyColumnIdentifier: Ref<string>;
+                            childrenColumnName: Ref<string>;
+                            checkStrictly: Ref<boolean>;
+                            expandRows: Ref<any[]>;
+                            defaultExpandAll: Ref<boolean>;
+                            tableSize: Ref<any>;
+                            rowKey: Ref<string | null>;
+                            data: Ref<any[]>;
+                            _data: Ref<any[]>;
+                            isComplex: Ref<boolean>;
+                            _columns: Ref< TableColumnCtx<any>[]>;
+                            originColumns: Ref< TableColumnCtx<any>[]>;
+                            columns: Ref< TableColumnCtx<any>[]>;
+                            fixedColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                            leafColumns: Ref< TableColumnCtx<any>[]>;
+                            fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            updateOrderFns: (() => void)[];
+                            leafColumnsLength: Ref<number>;
+                            fixedLeafColumnsLength: Ref<number>;
+                            rightFixedLeafColumnsLength: Ref<number>;
+                            isAllSelected: Ref<boolean>;
+                            selection: Ref<any[]>;
+                            reserveSelection: Ref<boolean>;
+                            selectOnIndeterminate: Ref<boolean>;
+                            selectable: Ref<((row: any, index: number) => boolean) | null>;
+                            filters: Ref<StoreFilter>;
+                            filteredData: Ref<any[] | null>;
+                            sortingColumn: Ref< TableColumnCtx<any> | null>;
+                            sortProp: Ref<string | null>;
+                            sortOrder: Ref<string | number | null>;
+                            hoverRow: Ref<any>;
+                        }, column: TableColumnCtx<any>, parent: TableColumnCtx<any>, updateColumnOrder: () => void): void;
+                        sort(states: {
+                            _currentRowKey: Ref<string | null>;
+                            currentRow: Ref<any>;
+                            expandRowKeys: Ref<(string | number)[]>;
+                            treeData: Ref<Record<string, TreeData>>;
+                            indent: Ref<number>;
+                            lazy: Ref<boolean>;
+                            lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                            lazyColumnIdentifier: Ref<string>;
+                            childrenColumnName: Ref<string>;
+                            checkStrictly: Ref<boolean>;
+                            expandRows: Ref<any[]>;
+                            defaultExpandAll: Ref<boolean>;
+                            tableSize: Ref<any>;
+                            rowKey: Ref<string | null>;
+                            data: Ref<any[]>;
+                            _data: Ref<any[]>;
+                            isComplex: Ref<boolean>;
+                            _columns: Ref< TableColumnCtx<any>[]>;
+                            originColumns: Ref< TableColumnCtx<any>[]>;
+                            columns: Ref< TableColumnCtx<any>[]>;
+                            fixedColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                            leafColumns: Ref< TableColumnCtx<any>[]>;
+                            fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            updateOrderFns: (() => void)[];
+                            leafColumnsLength: Ref<number>;
+                            fixedLeafColumnsLength: Ref<number>;
+                            rightFixedLeafColumnsLength: Ref<number>;
+                            isAllSelected: Ref<boolean>;
+                            selection: Ref<any[]>;
+                            reserveSelection: Ref<boolean>;
+                            selectOnIndeterminate: Ref<boolean>;
+                            selectable: Ref<((row: any, index: number) => boolean) | null>;
+                            filters: Ref<StoreFilter>;
+                            filteredData: Ref<any[] | null>;
+                            sortingColumn: Ref< TableColumnCtx<any> | null>;
+                            sortProp: Ref<string | null>;
+                            sortOrder: Ref<string | number | null>;
+                            hoverRow: Ref<any>;
+                        }, options: Sort): void;
+                        changeSortCondition(states: {
+                            _currentRowKey: Ref<string | null>;
+                            currentRow: Ref<any>;
+                            expandRowKeys: Ref<(string | number)[]>;
+                            treeData: Ref<Record<string, TreeData>>;
+                            indent: Ref<number>;
+                            lazy: Ref<boolean>;
+                            lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                            lazyColumnIdentifier: Ref<string>;
+                            childrenColumnName: Ref<string>;
+                            checkStrictly: Ref<boolean>;
+                            expandRows: Ref<any[]>;
+                            defaultExpandAll: Ref<boolean>;
+                            tableSize: Ref<any>;
+                            rowKey: Ref<string | null>;
+                            data: Ref<any[]>;
+                            _data: Ref<any[]>;
+                            isComplex: Ref<boolean>;
+                            _columns: Ref< TableColumnCtx<any>[]>;
+                            originColumns: Ref< TableColumnCtx<any>[]>;
+                            columns: Ref< TableColumnCtx<any>[]>;
+                            fixedColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                            leafColumns: Ref< TableColumnCtx<any>[]>;
+                            fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            updateOrderFns: (() => void)[];
+                            leafColumnsLength: Ref<number>;
+                            fixedLeafColumnsLength: Ref<number>;
+                            rightFixedLeafColumnsLength: Ref<number>;
+                            isAllSelected: Ref<boolean>;
+                            selection: Ref<any[]>;
+                            reserveSelection: Ref<boolean>;
+                            selectOnIndeterminate: Ref<boolean>;
+                            selectable: Ref<((row: any, index: number) => boolean) | null>;
+                            filters: Ref<StoreFilter>;
+                            filteredData: Ref<any[] | null>;
+                            sortingColumn: Ref< TableColumnCtx<any> | null>;
+                            sortProp: Ref<string | null>;
+                            sortOrder: Ref<string | number | null>;
+                            hoverRow: Ref<any>;
+                        }, options: Sort): void;
+                        filterChange(_states: {
+                            _currentRowKey: Ref<string | null>;
+                            currentRow: Ref<any>;
+                            expandRowKeys: Ref<(string | number)[]>;
+                            treeData: Ref<Record<string, TreeData>>;
+                            indent: Ref<number>;
+                            lazy: Ref<boolean>;
+                            lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                            lazyColumnIdentifier: Ref<string>;
+                            childrenColumnName: Ref<string>;
+                            checkStrictly: Ref<boolean>;
+                            expandRows: Ref<any[]>;
+                            defaultExpandAll: Ref<boolean>;
+                            tableSize: Ref<any>;
+                            rowKey: Ref<string | null>;
+                            data: Ref<any[]>;
+                            _data: Ref<any[]>;
+                            isComplex: Ref<boolean>;
+                            _columns: Ref< TableColumnCtx<any>[]>;
+                            originColumns: Ref< TableColumnCtx<any>[]>;
+                            columns: Ref< TableColumnCtx<any>[]>;
+                            fixedColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                            leafColumns: Ref< TableColumnCtx<any>[]>;
+                            fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            updateOrderFns: (() => void)[];
+                            leafColumnsLength: Ref<number>;
+                            fixedLeafColumnsLength: Ref<number>;
+                            rightFixedLeafColumnsLength: Ref<number>;
+                            isAllSelected: Ref<boolean>;
+                            selection: Ref<any[]>;
+                            reserveSelection: Ref<boolean>;
+                            selectOnIndeterminate: Ref<boolean>;
+                            selectable: Ref<((row: any, index: number) => boolean) | null>;
+                            filters: Ref<StoreFilter>;
+                            filteredData: Ref<any[] | null>;
+                            sortingColumn: Ref< TableColumnCtx<any> | null>;
+                            sortProp: Ref<string | null>;
+                            sortOrder: Ref<string | number | null>;
+                            hoverRow: Ref<any>;
+                        }, options: Filter<any>): void;
+                        toggleAllSelection(): void;
+                        rowSelectedChanged(_states: {
+                            _currentRowKey: Ref<string | null>;
+                            currentRow: Ref<any>;
+                            expandRowKeys: Ref<(string | number)[]>;
+                            treeData: Ref<Record<string, TreeData>>;
+                            indent: Ref<number>;
+                            lazy: Ref<boolean>;
+                            lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                            lazyColumnIdentifier: Ref<string>;
+                            childrenColumnName: Ref<string>;
+                            checkStrictly: Ref<boolean>;
+                            expandRows: Ref<any[]>;
+                            defaultExpandAll: Ref<boolean>;
+                            tableSize: Ref<any>;
+                            rowKey: Ref<string | null>;
+                            data: Ref<any[]>;
+                            _data: Ref<any[]>;
+                            isComplex: Ref<boolean>;
+                            _columns: Ref< TableColumnCtx<any>[]>;
+                            originColumns: Ref< TableColumnCtx<any>[]>;
+                            columns: Ref< TableColumnCtx<any>[]>;
+                            fixedColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                            leafColumns: Ref< TableColumnCtx<any>[]>;
+                            fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            updateOrderFns: (() => void)[];
+                            leafColumnsLength: Ref<number>;
+                            fixedLeafColumnsLength: Ref<number>;
+                            rightFixedLeafColumnsLength: Ref<number>;
+                            isAllSelected: Ref<boolean>;
+                            selection: Ref<any[]>;
+                            reserveSelection: Ref<boolean>;
+                            selectOnIndeterminate: Ref<boolean>;
+                            selectable: Ref<((row: any, index: number) => boolean) | null>;
+                            filters: Ref<StoreFilter>;
+                            filteredData: Ref<any[] | null>;
+                            sortingColumn: Ref< TableColumnCtx<any> | null>;
+                            sortProp: Ref<string | null>;
+                            sortOrder: Ref<string | number | null>;
+                            hoverRow: Ref<any>;
+                        }, row: any): void;
+                        setHoverRow(states: {
+                            _currentRowKey: Ref<string | null>;
+                            currentRow: Ref<any>;
+                            expandRowKeys: Ref<(string | number)[]>;
+                            treeData: Ref<Record<string, TreeData>>;
+                            indent: Ref<number>;
+                            lazy: Ref<boolean>;
+                            lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                            lazyColumnIdentifier: Ref<string>;
+                            childrenColumnName: Ref<string>;
+                            checkStrictly: Ref<boolean>;
+                            expandRows: Ref<any[]>;
+                            defaultExpandAll: Ref<boolean>;
+                            tableSize: Ref<any>;
+                            rowKey: Ref<string | null>;
+                            data: Ref<any[]>;
+                            _data: Ref<any[]>;
+                            isComplex: Ref<boolean>;
+                            _columns: Ref< TableColumnCtx<any>[]>;
+                            originColumns: Ref< TableColumnCtx<any>[]>;
+                            columns: Ref< TableColumnCtx<any>[]>;
+                            fixedColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                            leafColumns: Ref< TableColumnCtx<any>[]>;
+                            fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            updateOrderFns: (() => void)[];
+                            leafColumnsLength: Ref<number>;
+                            fixedLeafColumnsLength: Ref<number>;
+                            rightFixedLeafColumnsLength: Ref<number>;
+                            isAllSelected: Ref<boolean>;
+                            selection: Ref<any[]>;
+                            reserveSelection: Ref<boolean>;
+                            selectOnIndeterminate: Ref<boolean>;
+                            selectable: Ref<((row: any, index: number) => boolean) | null>;
+                            filters: Ref<StoreFilter>;
+                            filteredData: Ref<any[] | null>;
+                            sortingColumn: Ref< TableColumnCtx<any> | null>;
+                            sortProp: Ref<string | null>;
+                            sortOrder: Ref<string | number | null>;
+                            hoverRow: Ref<any>;
+                        }, row: any): void;
+                        setCurrentRow(_states: {
+                            _currentRowKey: Ref<string | null>;
+                            currentRow: Ref<any>;
+                            expandRowKeys: Ref<(string | number)[]>;
+                            treeData: Ref<Record<string, TreeData>>;
+                            indent: Ref<number>;
+                            lazy: Ref<boolean>;
+                            lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                            lazyColumnIdentifier: Ref<string>;
+                            childrenColumnName: Ref<string>;
+                            checkStrictly: Ref<boolean>;
+                            expandRows: Ref<any[]>;
+                            defaultExpandAll: Ref<boolean>;
+                            tableSize: Ref<any>;
+                            rowKey: Ref<string | null>;
+                            data: Ref<any[]>;
+                            _data: Ref<any[]>;
+                            isComplex: Ref<boolean>;
+                            _columns: Ref< TableColumnCtx<any>[]>;
+                            originColumns: Ref< TableColumnCtx<any>[]>;
+                            columns: Ref< TableColumnCtx<any>[]>;
+                            fixedColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                            leafColumns: Ref< TableColumnCtx<any>[]>;
+                            fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                            updateOrderFns: (() => void)[];
+                            leafColumnsLength: Ref<number>;
+                            fixedLeafColumnsLength: Ref<number>;
+                            rightFixedLeafColumnsLength: Ref<number>;
+                            isAllSelected: Ref<boolean>;
+                            selection: Ref<any[]>;
+                            reserveSelection: Ref<boolean>;
+                            selectOnIndeterminate: Ref<boolean>;
+                            selectable: Ref<((row: any, index: number) => boolean) | null>;
+                            filters: Ref<StoreFilter>;
+                            filteredData: Ref<any[] | null>;
+                            sortingColumn: Ref< TableColumnCtx<any> | null>;
+                            sortProp: Ref<string | null>;
+                            sortOrder: Ref<string | number | null>;
+                            hoverRow: Ref<any>;
+                        }, row: any): void;
+                    };
+                    commit: (name: "sort" | "setData" | "insertColumn" | "updateColumnOrder" | "removeColumn" | "changeSortCondition" | "filterChange" | "toggleAllSelection" | "rowSelectedChanged" | "setHoverRow" | "setCurrentRow", ...args: any[]) => void;
+                    updateTableScrollY: () => void;
+                    assertRowKey: () => void;
+                    updateColumns: () => void;
+                    scheduleLayout: (needUpdateColumns?: boolean, immediate?: boolean) => void;
+                    isSelected: (row: any) => boolean;
+                    clearSelection: () => void;
+                    cleanSelection: () => void;
+                    getSelectionRows: () => any[];
+                    toggleRowSelection: (row: any, selected?: boolean, emitChange?: boolean, ignoreSelectable?: boolean) => void;
+                    _toggleAllSelection: () => void;
+                    toggleAllSelection: (() => void) | null;
+                    updateAllSelected: () => void;
+                    updateFilters: (column: TableColumnCtx<any>, values: string[]) => Record<string, string[]>;
+                    updateCurrentRow: (_currentRow: any) => void;
+                    updateSort: (column: TableColumnCtx<any> | null, prop: string | null, order: TableSortOrder | null) => void;
+                    execFilter: () => void;
+                    execSort: () => void;
+                    execQuery: (ignore?: {
+                        filter: boolean;
+                    } | undefined) => void;
+                    clearFilter: (columnKeys?: string[] | string) => void;
+                    clearSort: () => void;
+                    toggleRowExpansion: (row: any, expanded?: boolean) => void;
+                    setExpandRowKeysAdapter: (val: (string | number)[]) => void;
+                    setCurrentRowKey: (key: string) => void;
+                    toggleRowExpansionAdapter: (row: any, expanded?: boolean) => void;
+                    isRowExpanded: (row: any) => boolean;
+                    updateExpandRows: () => void;
+                    updateCurrentRowData: () => void;
+                    loadOrToggle: (row: any) => void;
+                    updateTreeData: (ifChangeExpandRowKeys?: boolean, ifExpandAll?: boolean) => void;
+                    updateKeyChildren: (key: string, data: any[]) => void;
+                    states: {
+                        _currentRowKey: Ref<string | null>;
+                        currentRow: Ref<any>;
+                        expandRowKeys: Ref<(string | number)[]>;
+                        treeData: Ref<Record<string, TreeData>>;
+                        indent: Ref<number>;
+                        lazy: Ref<boolean>;
+                        lazyTreeNodeMap: Ref<Record<string, any[]>>;
+                        lazyColumnIdentifier: Ref<string>;
+                        childrenColumnName: Ref<string>;
+                        checkStrictly: Ref<boolean>;
+                        expandRows: Ref<any[]>;
+                        defaultExpandAll: Ref<boolean>;
+                        tableSize: Ref<any>;
+                        rowKey: Ref<string | null>;
+                        data: Ref<any[]>;
+                        _data: Ref<any[]>;
+                        isComplex: Ref<boolean>;
+                        _columns: Ref< TableColumnCtx<any>[]>;
+                        originColumns: Ref< TableColumnCtx<any>[]>;
+                        columns: Ref< TableColumnCtx<any>[]>;
+                        fixedColumns: Ref< TableColumnCtx<any>[]>;
+                        rightFixedColumns: Ref< TableColumnCtx<any>[]>;
+                        leafColumns: Ref< TableColumnCtx<any>[]>;
+                        fixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                        rightFixedLeafColumns: Ref< TableColumnCtx<any>[]>;
+                        updateOrderFns: (() => void)[];
+                        leafColumnsLength: Ref<number>;
+                        fixedLeafColumnsLength: Ref<number>;
+                        rightFixedLeafColumnsLength: Ref<number>;
+                        isAllSelected: Ref<boolean>;
+                        selection: Ref<any[]>;
+                        reserveSelection: Ref<boolean>;
+                        selectOnIndeterminate: Ref<boolean>;
+                        selectable: Ref<((row: any, index: number) => boolean) | null>;
+                        filters: Ref<StoreFilter>;
+                        filteredData: Ref<any[] | null>;
+                        sortingColumn: Ref< TableColumnCtx<any> | null>;
+                        sortProp: Ref<string | null>;
+                        sortOrder: Ref<string | number | null>;
+                        hoverRow: Ref<any>;
+                    };
+                    ns: {
+                        namespace: ComputedRef<string>;
+                        b: (blockSuffix?: string) => string;
+                        e: (element?: string) => string;
+                        m: (modifier?: string) => string;
+                        be: (blockSuffix?: string, element?: string) => string;
+                        em: (element?: string, modifier?: string) => string;
+                        bm: (blockSuffix?: string, modifier?: string) => string;
+                        bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+                        is: {
+                            (name: string, state: boolean | undefined): string;
+                            (name: string): string;
+                        };
+                        cssVar: (object: Record<string, string>) => Record<string, string>;
+                        cssVarName: (name: string) => string;
+                        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                        cssVarBlockName: (name: string) => string;
+                    };
+                };
+                columns: ComputedRef< TableColumnCtx<any>[]>;
+                handleHeaderFooterMousewheel: (_event: WheelEvent, data: any) => void;
+                handleMouseLeave: () => void;
+                tableId: string;
+                tableSize: ComputedRef<"" | "small" | "default" | "large">;
+                isHidden: Ref<boolean>;
+                isEmpty: ComputedRef<boolean>;
+                renderExpanded: Ref< RenderExpanded<any> | null>;
+                resizeProxyVisible: Ref<boolean>;
+                resizeState: Ref<{
+                    width: null | number;
+                    height: null | number;
+                    headerHeight: null | number;
+                }>;
+                isGroup: Ref<boolean>;
+                bodyWidth: ComputedRef<string>;
+                tableBodyStyles: ComputedRef<{
+                    width: string;
+                }>;
+                emptyBlockStyle: ComputedRef<{
+                    width: string;
+                    height: string;
+                } | undefined>;
+                debouncedUpdateLayout: DebouncedFunc<() => void>;
+                setCurrentRow: (row: any) => void;
+                getSelectionRows: () => any[];
+                toggleRowSelection: (row: any, selected?: boolean, ignoreSelectable?: boolean) => void;
+                clearSelection: () => void;
+                clearFilter: (columnKeys?: string[] | string) => void;
+                toggleAllSelection: () => void;
+                toggleRowExpansion: (row: any, expanded?: boolean) => void;
+                clearSort: () => void;
+                doLayout: () => void;
+                sort: (prop: string, order: string) => void;
+                updateKeyChildren: (key: string, data: any[]) => void;
+                t: Translator;
+                setDragVisible: (visible: boolean) => void;
+                context: Table<any>;
+                computedSumText: ComputedRef<string>;
+                computedEmptyText: ComputedRef<string>;
+                tableLayout: ComputedRef<("fixed" | "auto") | undefined>;
+                scrollbarViewStyle: {
+                    display: string;
+                    verticalAlign: string;
+                };
+                scrollbarStyle: ComputedRef<{
+                    height: string;
+                    maxHeight?: undefined;
+                } | {
+                    maxHeight: string;
+                    height?: undefined;
+                } | {
+                    height?: undefined;
+                    maxHeight?: undefined;
+                }>;
+                scrollBarRef: Ref<any>;
+                scrollTo: (options: ScrollToOptions | number, yCoord?: number) => void;
+                setScrollLeft: (left?: number) => void;
+                setScrollTop: (top?: number) => void;
+                allowDragLastColumn: boolean;
+            }, {}, {}, {}, {
+                data: any[];
+                style: CSSProperties;
+                tableLayout: "fixed" | "auto";
+                border: boolean;
+                className: string;
+                fit: boolean;
+                lazy: boolean;
+                scrollbarAlwaysOn: boolean;
+                allowDragLastColumn: boolean;
+                treeProps: TreeProps | undefined;
+                defaultExpandAll: boolean;
+                selectOnIndeterminate: boolean;
+                indent: number;
+                stripe: boolean;
+                showHeader: boolean;
+                showSummary: boolean;
+                highlightCurrentRow: boolean;
+                flexible: boolean;
+                scrollbarTabindex: string | number;
+                preserveExpandedContent: boolean;
+            }> | null;
+        };
+        $slots: Readonly<{
+            [name: string]: Slot<any> | undefined;
+        }>;
+        $root: ComponentPublicInstance | null;
+        $parent: ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: HTMLDivElement;
+        $options: ComponentOptionsBase<Readonly< ExtractPropTypes<{
+            defaultSort: {
+                type: () => DefaultSort;
+                default(): {};
+            };
+            height: {
+                type: (NumberConstructor | StringConstructor)[];
+                default(): string;
+            };
+            loading: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            adaptive: BooleanConstructor;
+            list: {
+                type: {
+                    (arrayLength: number): ListObj[];
+                    (...items: ListObj[]): ListObj[];
+                    new (arrayLength: number): ListObj[];
+                    new (...items: ListObj[]): ListObj[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                    fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                default(): never[];
+            };
+            value: {
+                type: {
+                    (arrayLength: number): ObjAny[];
+                    (...items: ObjAny[]): ObjAny[];
+                    new (arrayLength: number): ObjAny[];
+                    new (...items: ObjAny[]): ObjAny[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                    fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                default(): never[];
+            };
+            lineHeight: {
+                type: (NumberConstructor | StringConstructor)[];
+            };
+            options: {
+                type: ObjectConstructor;
+                default(): {};
+            };
+            compons: {
+                type: () => {
+                    [key: string]: Component;
+                };
+                default(): {};
+            };
+        }>> & Readonly<{}>, {
+            clearSelection: () => void;
+            toggleRowSelection: (...arr: any[]) => void;
+        }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
+            value: ObjAny[];
+            list: ListObj[];
+            loading: boolean;
+            options: Record<string, any>;
+            height: string | number;
+            compons: {
+                [key: string]: Component;
+            };
+            defaultSort: DefaultSort;
+            adaptive: boolean;
+        }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+    } & Readonly<{
+        value: ObjAny[];
+        list: ListObj[];
+        loading: boolean;
+        options: Record<string, any>;
+        height: string | number;
+        compons: {
+            [key: string]: Component;
+        };
+        defaultSort: DefaultSort;
+        adaptive: boolean;
+    }> & Omit<Readonly< ExtractPropTypes<{
+        defaultSort: {
+            type: () => DefaultSort;
+            default(): {};
+        };
+        height: {
+            type: (NumberConstructor | StringConstructor)[];
+            default(): string;
+        };
+        loading: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        adaptive: BooleanConstructor;
+        list: {
+            type: {
+                (arrayLength: number): ListObj[];
+                (...items: ListObj[]): ListObj[];
+                new (arrayLength: number): ListObj[];
+                new (...items: ListObj[]): ListObj[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+            default(): never[];
+        };
+        value: {
+            type: {
+                (arrayLength: number): ObjAny[];
+                (...items: ObjAny[]): ObjAny[];
+                new (arrayLength: number): ObjAny[];
+                new (...items: ObjAny[]): ObjAny[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+            default(): never[];
+        };
+        lineHeight: {
+            type: (NumberConstructor | StringConstructor)[];
+        };
+        options: {
+            type: ObjectConstructor;
+            default(): {};
+        };
+        compons: {
+            type: () => {
+                [key: string]: Component;
+            };
+            default(): {};
+        };
+    }>> & Readonly<{}>, "toggleRowSelection" | "clearSelection" | ("value" | "list" | "loading" | "options" | "height" | "compons" | "defaultSort" | "adaptive")> & ShallowUnwrapRef<{
+        clearSelection: () => void;
+        toggleRowSelection: (...arr: any[]) => void;
+    }> & {} & ComponentCustomProperties & {} & {
+        $slots: Partial<Record<string, (_: any) => any>> & {
+            'no-data'?(_: {}): any;
+        };
+    }) | null;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};