element-pe 1.0.2 → 1.0.6

package/es/components/table/src/config.d.ts

@@ -0,0 +1,82 @@
+import type { TableColumnCtx } from './table-column/defaults';
+import type { Store } from './store';
+import type { TreeNode } from './table/defaults';
+export declare const cellStarts: {
+    default: {
+        order: string;
+    };
+    selection: {
+        width: number;
+        minWidth: number;
+        realWidth: number;
+        order: string;
+        className: string;
+    };
+    expand: {
+        width: number;
+        minWidth: number;
+        realWidth: number;
+        order: string;
+    };
+    index: {
+        width: number;
+        minWidth: number;
+        realWidth: number;
+        order: string;
+    };
+};
+export declare const cellForced: {
+    selection: {
+        renderHeader<T>({ store }: {
+            store: any;
+        }): import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>;
+        renderCell<T_1>({ row, column, store, $index, }: {
+            row: T_1;
+            column: TableColumnCtx<T_1>;
+            store: any;
+            $index: string;
+        }): import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>;
+        sortable: boolean;
+        resizable: boolean;
+    };
+    index: {
+        renderHeader<T_2>({ column }: {
+            column: TableColumnCtx<T_2>;
+        }): string;
+        renderCell<T_3>({ column, $index, }: {
+            column: TableColumnCtx<T_3>;
+            $index: number;
+        }): import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>;
+        sortable: boolean;
+    };
+    expand: {
+        renderHeader<T_4>({ column }: {
+            column: TableColumnCtx<T_4>;
+        }): string;
+        renderCell<T_5>({ row, store }: {
+            row: T_5;
+            store: any;
+        }): import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>;
+        sortable: boolean;
+        resizable: boolean;
+        className: string;
+    };
+};
+export declare function defaultRenderCell<T>({ row, column, $index, }: {
+    row: T;
+    column: TableColumnCtx<T>;
+    $index: number;
+}): any;
+export declare function treeCellPrefix<T>({ row, treeNode, store, }: {
+    row: T;
+    treeNode: TreeNode;
+    store: Store<T>;
+}): never[] | null;

package/es/components/table/src/filter-panel.vue.d.ts

@@ -0,0 +1,49 @@
+import { Effect } from 'element-pe/es/components/popper';
+import type { Placement } from 'element-pe/es/components/popper';
+import type { WritableComputedRef, PropType } from 'vue';
+import type { TableColumnCtx } from './table-column/defaults';
+declare const _default: import("vue").DefineComponent<{
+    placement: {
+        type: PropType<Placement>;
+        default: string;
+    };
+    store: {
+        type: PropType<any>;
+    };
+    column: {
+        type: PropType<TableColumnCtx<unknown>>;
+    };
+    upDataColumn: {
+        type: FunctionConstructor;
+    };
+}, {
+    tooltipVisible: import("vue").Ref<boolean>;
+    multiple: import("vue").ComputedRef<boolean>;
+    filteredValue: WritableComputedRef<unknown[]>;
+    filterValue: WritableComputedRef<string>;
+    filters: import("vue").ComputedRef<import("./table-column/defaults").Filters | undefined>;
+    handleConfirm: () => void;
+    handleReset: () => void;
+    handleSelect: (_filterValue?: string | undefined) => void;
+    isActive: (filter: any) => boolean;
+    t: (...args: any[]) => string;
+    showFilterPanel: (e: MouseEvent) => void;
+    hideFilterPanel: () => void;
+    popperPaneRef: import("vue").ComputedRef<any>;
+    tooltip: import("vue").Ref<null>;
+    Effect: typeof Effect;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    placement?: unknown;
+    store?: unknown;
+    column?: unknown;
+    upDataColumn?: unknown;
+} & {
+    placement: Placement;
+} & {
+    column?: TableColumnCtx<unknown> | undefined;
+    store?: unknown;
+    upDataColumn?: Function | undefined;
+}>, {
+    placement: Placement;
+}>;
+export default _default;

package/es/components/table/src/store/expand.d.ts

@@ -2,7 +2,7 @@ import type { Ref } from 'vue';
 import type { WatcherPropsData } from './index';
 declare function useExpand<T>(watcherData: WatcherPropsData<T>): {
     updateExpandRows: () => void;
-    toggleRowExpansion: (row: T, expanded?: boolean) => void;
+    toggleRowExpansion: (row: T, expanded?: boolean | undefined) => void;
     setExpandRowKeys: (rowKeys: string[]) => void;
     isRowExpanded: (row: T) => boolean;
     states: {

package/es/components/table/src/store/helper.d.ts

@@ -0,0 +1,2 @@
+import type { Table, TableProps } from '../table/defaults';
+export declare function createStore<T>(table: Table<T>, props: TableProps<T>): any;

package/es/components/table/src/store/index.d.ts

@@ -0,0 +1,13 @@
+import type { Ref } from 'vue';
+interface WatcherPropsData<T> {
+    data: Ref<T[]>;
+    rowKey: Ref<string>;
+}
+declare function useStore<T>(): any;
+export default useStore;
+declare class HelperStore<T> {
+    Return: any;
+}
+declare type StoreFilter = Record<string, string[]>;
+declare type Store<T> = HelperStore<T>['Return'];
+export type { WatcherPropsData, Store, StoreFilter };

package/es/components/table/src/table/defaults.d.ts

@@ -0,0 +1,223 @@
+import type { ComponentInternalInstance, CSSProperties, Ref, VNode, PropType } from 'vue';
+import type { Nullable } from 'element-pe/es/utils/types';
+import type { Store } from '../store';
+import type { TableColumnCtx } from '../table-column/defaults';
+import type TableLayout from '../table-layout';
+export declare type DefaultRow = any;
+interface TableRefs {
+    headerWrapper: HTMLElement;
+    footerWrapper: HTMLElement;
+    fixedBodyWrapper: HTMLElement;
+    rightFixedBodyWrapper: HTMLElement;
+    bodyWrapper: HTMLElement;
+    [key: string]: any;
+}
+interface TableState {
+    isGroup: Ref<boolean>;
+    resizeState: Ref<{
+        width: any;
+        height: any;
+    }>;
+    doLayout: () => void;
+    debouncedUpdateLayout: () => void;
+}
+declare type HoverState<T> = Nullable<{
+    cell: HTMLElement;
+    column: TableColumnCtx<T>;
+    row: T;
+}>;
+declare type RIS<T> = {
+    row: T;
+    $index: number;
+    store: Store<T>;
+};
+declare type RenderExpanded<T> = ({ row, $index, store }: RIS<T>) => VNode;
+declare type SummaryMethod<T> = (data: {
+    columns: TableColumnCtx<T>;
+    data: T[];
+}) => string[];
+interface Table<T> extends ComponentInternalInstance {
+    $ready: boolean;
+    hoverState?: HoverState<T>;
+    renderExpanded: RenderExpanded<T>;
+    store: Store<T>;
+    layout: TableLayout<T>;
+    refs: TableRefs;
+    tableId: string;
+    state: TableState;
+}
+declare type ColumnCls<T> = string | ((data: {
+    row: T;
+    rowIndex: number;
+}) => string);
+declare type ColumnStyle<T> = CSSProperties | ((data: {
+    row: T;
+    rowIndex: number;
+}) => CSSProperties);
+declare type CellCls<T> = string | ((data: {
+    row: T;
+    rowIndex: number;
+    column: TableColumnCtx<T>;
+    columnIndex: number;
+}) => string);
+declare type CellStyle<T> = CSSProperties | ((data: {
+    row: T;
+    rowIndex: number;
+    column: TableColumnCtx<T>;
+    columnIndex: number;
+}) => CSSProperties);
+interface TableProps<T> {
+    data: T[];
+    size?: string;
+    width?: string | number;
+    height?: string | number;
+    maxHeight?: string | number;
+    fit?: boolean;
+    stripe?: boolean;
+    border?: boolean;
+    rowKey?: string | ((row: T) => string);
+    context?: Table<T>;
+    showHeader?: boolean;
+    showSummary?: boolean;
+    sumText?: string;
+    summaryMethod?: SummaryMethod<T>;
+    rowClassName?: ColumnCls<T>;
+    rowStyle?: ColumnStyle<T>;
+    cellClassName?: CellCls<T>;
+    cellStyle?: CellStyle<T>;
+    headerRowClassName?: ColumnCls<T>;
+    headerRowStyle?: ColumnStyle<T>;
+    headerCellClassName?: CellCls<T>;
+    headerCellStyle?: CellStyle<T>;
+    highlightCurrentRow?: boolean;
+    currentRowKey?: string | number;
+    emptyText?: string;
+    expandRowKeys?: any[];
+    defaultExpandAll?: boolean;
+    defaultSort?: Sort;
+    tooltipEffect?: string;
+    spanMethod?: (data: {
+        row: T;
+        rowIndex: number;
+        column: TableColumnCtx<T>;
+        columnIndex: number;
+    }) => number[] | {
+        rowspan: number;
+        colspan: number;
+    };
+    selectOnIndeterminate?: boolean;
+    indent?: number;
+    treeProps?: {
+        hasChildren?: string;
+        children?: string;
+    };
+    lazy?: boolean;
+    load?: (row: T, treeNode: TreeNode, resolve: (data: T[]) => void) => void;
+    className?: string;
+    style?: CSSProperties;
+}
+interface Sort {
+    prop: string;
+    order: 'ascending' | 'descending';
+    init?: any;
+    silent?: any;
+}
+interface Filter<T> {
+    column: TableColumnCtx<T>;
+    values: string[];
+    silent: any;
+}
+interface TreeNode {
+    expanded?: boolean;
+    loading?: boolean;
+    noLazyChildren?: boolean;
+    indent?: number;
+    level?: number;
+    display?: boolean;
+}
+interface RenderRowData<T> {
+    store: Store<T>;
+    _self: Table<T>;
+    column: TableColumnCtx<T>;
+    row: T;
+    $index: number;
+    treeNode?: TreeNode;
+}
+declare const _default: {
+    data: {
+        type: PropType<any[]>;
+        default: () => never[];
+    };
+    size: StringConstructor;
+    width: (NumberConstructor | StringConstructor)[];
+    height: (NumberConstructor | StringConstructor)[];
+    maxHeight: (NumberConstructor | StringConstructor)[];
+    fit: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    stripe: BooleanConstructor;
+    border: BooleanConstructor;
+    rowKey: PropType<string | ((row: any) => string) | undefined>;
+    showHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showSummary: BooleanConstructor;
+    sumText: StringConstructor;
+    summaryMethod: PropType<SummaryMethod<any> | undefined>;
+    rowClassName: PropType<ColumnCls<any> | undefined>;
+    rowStyle: PropType<ColumnStyle<any> | undefined>;
+    cellClassName: PropType<CellCls<any> | undefined>;
+    cellStyle: PropType<CellStyle<any> | undefined>;
+    headerRowClassName: PropType<ColumnCls<any> | undefined>;
+    headerRowStyle: PropType<ColumnStyle<any> | undefined>;
+    headerCellClassName: PropType<CellCls<any> | undefined>;
+    headerCellStyle: PropType<CellStyle<any> | undefined>;
+    highlightCurrentRow: BooleanConstructor;
+    currentRowKey: (NumberConstructor | StringConstructor)[];
+    emptyText: StringConstructor;
+    expandRowKeys: PropType<any[] | undefined>;
+    defaultExpandAll: BooleanConstructor;
+    defaultSort: PropType<Sort | undefined>;
+    tooltipEffect: StringConstructor;
+    spanMethod: PropType<((data: {
+        row: any;
+        rowIndex: number;
+        column: TableColumnCtx<any>;
+        columnIndex: number;
+    }) => number[] | {
+        rowspan: number;
+        colspan: number;
+    }) | undefined>;
+    selectOnIndeterminate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    indent: {
+        type: NumberConstructor;
+        default: number;
+    };
+    treeProps: {
+        type: PropType<{
+            hasChildren?: string | undefined;
+            children?: string | undefined;
+        } | undefined>;
+        default: () => {
+            hasChildren: string;
+            children: string;
+        };
+    };
+    lazy: BooleanConstructor;
+    load: PropType<((row: any, treeNode: TreeNode, resolve: (data: any[]) => void) => void) | undefined>;
+    style: {
+        type: PropType<CSSProperties>;
+        default: () => {};
+    };
+    className: {
+        type: StringConstructor;
+        default: string;
+    };
+};
+export default _default;
+export type { SummaryMethod, Table, TableProps, TableRefs, ColumnCls, ColumnStyle, TreeNode, RenderRowData, Sort, Filter, };

package/es/components/table/src/table/style-helper.d.ts

@@ -0,0 +1,55 @@
+import type { Table, TableProps } from './defaults';
+import type { Store } from '../store';
+import type TableLayout from '../table-layout';
+declare function useStyle<T>(props: TableProps<T>, layout: TableLayout<T>, store: Store<T>, table: Table<T>): {
+    isHidden: import("vue").Ref<boolean>;
+    renderExpanded: import("vue").Ref<null>;
+    setDragVisible: (visible: boolean) => void;
+    isGroup: import("vue").Ref<boolean>;
+    handleMouseLeave: () => void;
+    handleHeaderFooterMousewheel: (event: any, data: any) => void;
+    tableSize: import("vue").ComputedRef<any>;
+    bodyHeight: import("vue").ComputedRef<{
+        height: string;
+        'max-height'?: undefined;
+    } | {
+        'max-height': string;
+        height?: undefined;
+    } | {
+        height?: undefined;
+        'max-height'?: undefined;
+    }>;
+    emptyBlockStyle: import("vue").ComputedRef<{
+        width: string;
+        height: string;
+    } | null>;
+    handleFixedMousewheel: (event: any, data: any) => void;
+    fixedHeight: import("vue").ComputedRef<{
+        bottom: number;
+        height?: undefined;
+    } | {
+        bottom: string;
+        height?: undefined;
+    } | {
+        height: string;
+        bottom?: undefined;
+    }>;
+    fixedBodyHeight: import("vue").ComputedRef<{
+        height: string;
+        'max-height'?: undefined;
+    } | {
+        'max-height': string;
+        height?: undefined;
+    } | {
+        height?: undefined;
+        'max-height'?: undefined;
+    }>;
+    resizeProxyVisible: import("vue").Ref<boolean>;
+    bodyWidth: import("vue").ComputedRef<string>;
+    resizeState: import("vue").Ref<{
+        width: null;
+        height: null;
+    }>;
+    doLayout: () => void;
+};
+export default useStyle;

package/es/components/table/src/table/utils-helper.d.ts

@@ -0,0 +1,12 @@
+import type { Store } from '../store';
+declare function useUtils<T>(store: Store<T>): {
+    setCurrentRow: (row: T) => void;
+    toggleRowSelection: (row: T, selected: boolean) => void;
+    clearSelection: () => void;
+    clearFilter: (columnKeys: string[]) => void;
+    toggleAllSelection: () => void;
+    toggleRowExpansion: (row: T, expanded: boolean) => void;
+    clearSort: () => void;
+    sort: (prop: string, order: string) => void;
+};
+export default useUtils;

package/es/components/table/src/table-body/defaults.d.ts

@@ -0,0 +1,34 @@
+import type { PropType } from 'vue';
+import type { Store } from '../store';
+import type { ColumnCls, ColumnStyle, Table } from '../table/defaults';
+interface TableBodyProps<T> {
+    store: Store<T>;
+    stripe?: boolean;
+    context: Table<T>;
+    rowClassName: ColumnCls<T>;
+    rowStyle: ColumnStyle<T>;
+    fixed: string;
+    highlight: boolean;
+    tooltipEffect: string;
+}
+declare const defaultProps: {
+    store: {
+        required: boolean;
+        type: PropType<any>;
+    };
+    stripe: BooleanConstructor;
+    tooltipEffect: StringConstructor;
+    context: {
+        default: () => {};
+        type: PropType<Table<any>>;
+    };
+    rowClassName: PropType<ColumnCls<any>>;
+    rowStyle: PropType<ColumnStyle<any>>;
+    fixed: {
+        type: StringConstructor;
+        default: string;
+    };
+    highlight: BooleanConstructor;
+};
+export { TableBodyProps };
+export default defaultProps;

package/es/components/table/src/table-body/index.d.ts

@@ -0,0 +1,60 @@
+import type { VNode } from 'vue';
+import type { Table } from '../table/defaults';
+declare const _default: import("vue").DefineComponent<{
+    store: {
+        required: boolean;
+        type: import("vue").PropType<any>;
+    };
+    stripe: BooleanConstructor;
+    tooltipEffect: StringConstructor;
+    context: {
+        default: () => {};
+        type: import("vue").PropType<Table<any>>;
+    };
+    rowClassName: import("vue").PropType<import("../table/defaults").ColumnCls<any>>;
+    rowStyle: import("vue").PropType<import("../table/defaults").ColumnStyle<any>>;
+    fixed: {
+        type: StringConstructor;
+        default: string;
+    };
+    highlight: BooleanConstructor;
+}, {
+    onColumnsChange: (layout: import("../table-layout").default<any>) => void;
+    onScrollableChange: (layout: import("../table-layout").default<any>) => void;
+    wrappedRowRender: (row: any, $index: number) => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>[] | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>[][];
+    tooltipContent: import("vue").Ref<string>;
+    tooltipTrigger: import("vue").Ref<VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    store?: unknown;
+    stripe?: unknown;
+    tooltipEffect?: unknown;
+    context?: unknown;
+    rowClassName?: unknown;
+    rowStyle?: unknown;
+    fixed?: unknown;
+    highlight?: unknown;
+} & {
+    fixed: string;
+    highlight: boolean;
+    context: Table<any>;
+    stripe: boolean;
+} & {
+    store?: unknown;
+    rowClassName?: import("../table/defaults").ColumnCls<any> | undefined;
+    rowStyle?: import("../table/defaults").ColumnStyle<any> | undefined;
+    tooltipEffect?: string | undefined;
+}>, {
+    fixed: string;
+    highlight: boolean;
+    context: Table<any>;
+    stripe: boolean;
+}>;
+export default _default;

package/es/components/table/src/table-column/defaults.d.ts

@@ -118,8 +118,8 @@ declare const _default: {
     };
     index: PropType<number | ((index: number) => number)>;
     sortOrders: {
-        type: PropType<("ascending" | "descending")[]>;
-        default: () => string[];
+        type: PropType<("ascending" | "descending" | null)[]>;
+        default: () => (string | null)[];
         validator: (val: TableColumnCtx<unknown>['sortOrders']) => boolean;
     };
     widget: StringConstructor;

package/es/components/table/src/table-column/index.d.ts

@@ -54,9 +54,9 @@ declare const _default: import("vue").DefineComponent<{
     };
     index: import("vue").PropType<number | ((index: number) => number)>;
     sortOrders: {
-        type: import("vue").PropType<("ascending" | "descending")[]>;
-        default: () => string[];
-        validator: (val: ("ascending" | "descending")[]) => boolean;
+        type: import("vue").PropType<("ascending" | "descending" | null)[]>;
+        default: () => (string | null)[];
+        validator: (val: ("ascending" | "descending" | null)[]) => boolean;
     };
     widget: StringConstructor;
 }, void, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
@@ -91,54 +91,54 @@ declare const _default: import("vue").DefineComponent<{
     sortOrders?: unknown;
     widget?: unknown;
 } & {
-    width: string | number;
     type: string;
+    width: string | number;
     minWidth: string | number;
-    sortOrders: ("ascending" | "descending")[];
-    filterMultiple: boolean;
+    sortOrders: ("ascending" | "descending" | null)[];
     sortable: string | boolean;
-    showOverflowTooltip: boolean;
     resizable: boolean;
     showTooltipWhenOverflow: boolean;
+    showOverflowTooltip: boolean;
     reserveSelection: boolean;
+    filterMultiple: boolean;
 } & {
-    fixed?: string | boolean;
-    filters?: import("./defaults").Filters;
-    label?: string;
-    widget?: string;
-    index?: number | ((index: number) => number);
-    filterMethod?: import("./defaults").FilterMethods<any>;
-    align?: string;
-    className?: string;
-    labelClassName?: string;
-    prop?: string;
-    filteredValue?: string[];
-    renderHeader?: (data: {
+    fixed?: string | boolean | undefined;
+    label?: string | undefined;
+    widget?: string | undefined;
+    filters?: import("./defaults").Filters | undefined;
+    index?: number | ((index: number) => number) | undefined;
+    filterMethod?: import("./defaults").FilterMethods<any> | undefined;
+    align?: string | undefined;
+    className?: string | undefined;
+    labelClassName?: string | undefined;
+    prop?: string | undefined;
+    renderHeader?: ((data: {
         column: TableColumnCtx<any>;
         $index: number;
     }) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
         [key: string]: any;
-    }>;
-    sortMethod?: (a: any, b: any) => number;
-    sortBy?: string | string[] | ((row: any, index: number) => string);
-    formatter?: (row: any, column: TableColumnCtx<any>, cellValue: any, index: number) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    }>) | undefined;
+    sortMethod?: ((a: any, b: any) => number) | undefined;
+    sortBy?: string | string[] | ((row: any, index: number) => string) | undefined;
+    formatter?: ((row: any, column: TableColumnCtx<any>, cellValue: any, index: number) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
         [key: string]: any;
-    }>;
-    selectable?: (row: any, index: number) => boolean;
-    property?: string;
-    columnKey?: string;
-    headerAlign?: string;
-    filterPlacement?: string;
+    }>) | undefined;
+    selectable?: ((row: any, index: number) => boolean) | undefined;
+    filteredValue?: string[] | undefined;
+    property?: string | undefined;
+    columnKey?: string | undefined;
+    headerAlign?: string | undefined;
+    filterPlacement?: string | undefined;
 }>, {
-    width: string | number;
     type: string;
+    width: string | number;
     minWidth: string | number;
-    sortOrders: ("ascending" | "descending")[];
-    filterMultiple: boolean;
+    sortOrders: ("ascending" | "descending" | null)[];
     sortable: string | boolean;
-    showOverflowTooltip: boolean;
     resizable: boolean;
     showTooltipWhenOverflow: boolean;
+    showOverflowTooltip: boolean;
     reserveSelection: boolean;
+    filterMultiple: boolean;
 }>;
 export default _default;

package/es/components/table/src/table-column/render-helper.d.ts

@@ -2,14 +2,14 @@ import type { ComputedRef } from 'vue';
 import type { TableColumnCtx } from './defaults';
 declare function useRender<T>(props: TableColumnCtx<T>, slots: any, owner: ComputedRef<any>): {
     columnId: import("vue").Ref<string>;
-    realAlign: import("vue").Ref<string>;
+    realAlign: import("vue").Ref<string | undefined>;
     isSubColumn: import("vue").Ref<boolean>;
-    realHeaderAlign: import("vue").Ref<string>;
+    realHeaderAlign: import("vue").Ref<string | undefined>;
     columnOrTableParent: ComputedRef<any>;
     setColumnWidth: (column: TableColumnCtx<T>) => TableColumnCtx<T>;
     setColumnForcedProps: (column: TableColumnCtx<T>) => TableColumnCtx<T>;
     setColumnRenders: (column: TableColumnCtx<T>) => TableColumnCtx<T>;
     getPropsData: (...propsKey: unknown[]) => unknown;
-    getColumnElIndex: (children: any, child: any) => any;
+    getColumnElIndex: (children: any, child: any) => number;
 };
 export default useRender;