bkui-vue 0.0.2-beta.1 → 0.0.2-beta.100

package/lib/table-column/index.d.ts

@@ -3,34 +3,23 @@ declare const BkTableColumn: {
         $: import("vue").ComponentInternalInstance;
         $data: {};
         $props: {
-            sort?: string | boolean | {
-                sortFn: any;
-                sortScope: (object | "all" | "current" | (() => "all" | "current") | ((props: Record<string, unknown>) => "all" | "current")) & ("all" | "current");
-                value: string;
-            };
-            filter?: string | boolean | {
-                list: any[] | (object & (() => any[]));
-                filterFn: any;
-                match: "full" | "fuzzy";
-                checked: any[] | (object & (() => any[]));
-                filterScope: (object | "all" | "current" | (() => "all" | "current") | ((props: Record<string, unknown>) => "all" | "current")) & ("all" | "current");
-                btnSave: (string | boolean | object | (() => string | boolean) | ((props: Record<string, unknown>) => string | boolean)) & (string | boolean);
-                btnReset: (string | boolean | object | (() => string | boolean) | ((props: Record<string, unknown>) => string | boolean)) & (string | boolean);
-            };
             fixed?: boolean | "right" | "left";
             minWidth?: string | number;
+            resizable?: boolean;
             index?: number;
             columnKey?: string;
-            showOverflowTooltip?: boolean | import("../../table/src/props").IOverflowTooltip;
-            resizable?: boolean;
+            colspan?: import("../../table/src/props").SpanFunctionString;
+            rowspan?: import("../../table/src/props").SpanFunctionString;
+            readonly render?: import("../../table/src/props").RenderFunctionString;
+            readonly sort?: import("../../table/src/props").ISortPropShape;
+            readonly filter?: import("../../table/src/props").IFilterPropShape;
             readonly type?: "none" | "selection" | "index" | "expand";
-            readonly render?: any;
             class?: unknown;
-            readonly label?: any;
+            readonly label?: import("../../table/src/props").LabelFunctionString;
             style?: unknown;
             readonly width?: string | number;
-            key?: string | number | symbol;
             ref?: import("vue").VNodeRef;
+            key?: string | number | symbol;
             ref_for?: boolean;
             ref_key?: string;
             onVnodeBeforeMount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
@@ -71,12 +60,11 @@ declare const BkTableColumn: {
             }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                 [key: string]: any;
             }>) => void)[];
-            readonly className?: any;
+            readonly className?: import("../../table/src/props").RowClassFunctionString;
             readonly align?: "" | "right" | "left" | "center";
-            readonly field?: any;
-            readonly colspan?: any;
-            readonly rowspan?: any;
-            readonly prop?: any;
+            readonly showOverflowTooltip?: import("../../table/src/props").IOverflowTooltipProp;
+            readonly field?: import("../../table/src/props").LabelFunctionString;
+            readonly prop?: import("../../table/src/props").LabelFunctionString;
         };
         $attrs: {
             [x: string]: unknown;
@@ -92,15 +80,9 @@ declare const BkTableColumn: {
         $emit: (event: string, ...args: any[]) => void;
         $el: any;
         $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-            prop: import("vue-types").VueTypeDef<any>;
-            index: import("vue-types").VueTypeValidableDef<number> & {
-                default: number;
-            } & {
-                default: number;
-            };
-            label: import("vue-types").VueTypeDef<any>;
-            field: import("vue-types").VueTypeDef<any>;
-            render: import("vue-types").VueTypeDef<any>;
+            label: import("vue-types").VueTypeDef<import("../../table/src/props").LabelFunctionString>;
+            field: import("vue-types").VueTypeDef<import("../../table/src/props").LabelFunctionString>;
+            render: import("vue-types").VueTypeDef<import("../../table/src/props").RenderFunctionString>;
             width: import("vue-types").VueTypeDef<string | number>;
             minWidth: import("vue-types").VueTypeDef<string | number> & {
                 default: string | number;
@@ -110,9 +92,7 @@ declare const BkTableColumn: {
             } & {
                 default: string;
             };
-            showOverflowTooltip: import("vue-types").VueTypeDef<boolean | import("../../table/src/props").IOverflowTooltip> & {
-                default: boolean | (() => import("../../table/src/props").IOverflowTooltip);
-            };
+            showOverflowTooltip: import("vue-types").VueTypeDef<import("../../table/src/props").IOverflowTooltipProp>;
             type: import("vue-types").VueTypeDef<"none" | "selection" | "index" | "expand">;
             resizable: import("vue-types").VueTypeValidableDef<boolean> & {
                 default: boolean;
@@ -122,72 +102,49 @@ declare const BkTableColumn: {
             fixed: import("vue-types").VueTypeDef<boolean | "right" | "left"> & {
                 default: boolean | "right" | "left";
             };
-            sort: import("vue-types").VueTypeDef<string | boolean | {
-                sortFn: any;
-                sortScope: (object | "all" | "current" | (() => "all" | "current") | ((props: Record<string, unknown>) => "all" | "current")) & ("all" | "current");
-                value: string;
-            }> & {
-                default: string | boolean | (() => {
-                    sortFn: any;
-                    sortScope: (object | "all" | "current" | (() => "all" | "current") | ((props: Record<string, unknown>) => "all" | "current")) & ("all" | "current");
-                    value: string;
-                });
+            sort: import("vue-types").VueTypeDef<import("../../table/src/props").ISortPropShape>;
+            filter: import("vue-types").VueTypeDef<import("../../table/src/props").IFilterPropShape>;
+            colspan: import("vue-types").VueTypeDef<import("../../table/src/props").SpanFunctionString> & {
+                default: (({ column, colIndex, row, rowIndex }: {
+                    column: any;
+                    colIndex: any;
+                    row: any;
+                    rowIndex: any;
+                }) => number) | (() => Number);
             };
-            filter: import("vue-types").VueTypeDef<string | boolean | {
-                list: any[] | (object & (() => any[]));
-                filterFn: any;
-                match: "full" | "fuzzy";
-                checked: any[] | (object & (() => any[]));
-                filterScope: (object | "all" | "current" | (() => "all" | "current") | ((props: Record<string, unknown>) => "all" | "current")) & ("all" | "current");
-                btnSave: (string | boolean | object | (() => string | boolean) | ((props: Record<string, unknown>) => string | boolean)) & (string | boolean);
-                btnReset: (string | boolean | object | (() => string | boolean) | ((props: Record<string, unknown>) => string | boolean)) & (string | boolean);
-            }> & {
-                default: string | boolean | (() => {
-                    list: any[] | (object & (() => any[]));
-                    filterFn: any;
-                    match: "full" | "fuzzy";
-                    checked: any[] | (object & (() => any[]));
-                    filterScope: (object | "all" | "current" | (() => "all" | "current") | ((props: Record<string, unknown>) => "all" | "current")) & ("all" | "current");
-                    btnSave: (string | boolean | object | (() => string | boolean) | ((props: Record<string, unknown>) => string | boolean)) & (string | boolean);
-                    btnReset: (string | boolean | object | (() => string | boolean) | ((props: Record<string, unknown>) => string | boolean)) & (string | boolean);
-                });
+            rowspan: import("vue-types").VueTypeDef<import("../../table/src/props").SpanFunctionString> & {
+                default: (({ column, colIndex, row, rowIndex }: {
+                    column: any;
+                    colIndex: any;
+                    row: any;
+                    rowIndex: any;
+                }) => number) | (() => Number);
             };
-            colspan: import("vue-types").VueTypeDef<any>;
-            rowspan: import("vue-types").VueTypeDef<any>;
             align: import("vue-types").VueTypeDef<"" | "right" | "left" | "center">;
-            className: import("vue-types").VueTypeDef<any>;
+            className: import("vue-types").VueTypeDef<import("../../table/src/props").RowClassFunctionString>;
+            prop: import("vue-types").VueTypeDef<import("../../table/src/props").LabelFunctionString>;
+            index: import("vue-types").VueTypeValidableDef<number> & {
+                default: number;
+            } & {
+                default: number;
+            };
         }>>, {
-            initColumns: (_col: import("../../table/src/components/table-column").ITableColumn | import("../../table/src/components/table-column").ITableColumn[], _rm?: boolean) => void;
+            initColumns: (_col: import("../../bkui-vue").TableIColumn | import("../../bkui-vue").TableIColumn[], _rm?: boolean) => void;
             bkTableCache: {
                 queueStack: (_: any, fn: any) => any;
             };
             column: {
-                field: string | Function;
-                label: string | Function;
-                render?: string | Function | import("vue").Slot<any>;
-                width?: string | number;
+                fixed?: boolean | "right" | "left";
                 minWidth?: string | number;
-                columnKey?: string;
-                showOverflowTooltip?: boolean | {
-                    content: string | Function;
-                    disabled?: boolean;
-                    watchCellResize?: boolean;
-                    mode?: "auto" | "static";
-                };
-                type?: string;
-                fixed?: string | boolean;
                 resizable?: boolean;
-                sort?: string | boolean | {
-                    sortFn?: Function;
-                    sortScope?: string;
-                    value?: string;
-                };
-                filter?: string | boolean | {
-                    list?: any;
-                    filterFn?: Function;
-                    checked?: any;
-                };
-                colspan?: Function | {
+                index?: number;
+                columnKey?: string;
+                colspan?: (({ column, colIndex, row, rowIndex }: {
+                    column: any;
+                    colIndex: any;
+                    row: any;
+                    rowIndex: any;
+                }) => number) | {
                     toString: (radix?: number) => string;
                     toFixed: (fractionDigits?: number) => string;
                     toExponential: (fractionDigits?: number) => string;
@@ -198,7 +155,12 @@ declare const BkTableColumn: {
                         (locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): string;
                     };
                 };
-                rowspan?: Function | {
+                rowspan?: (({ column, colIndex, row, rowIndex }: {
+                    column: any;
+                    colIndex: any;
+                    row: any;
+                    rowIndex: any;
+                }) => number) | {
                     toString: (radix?: number) => string;
                     toFixed: (fractionDigits?: number) => string;
                     toExponential: (fractionDigits?: number) => string;
@@ -209,121 +171,101 @@ declare const BkTableColumn: {
                         (locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): string;
                     };
                 };
-                textAlign?: {
-                    [x: number]: string;
-                    toString: () => string;
-                    charAt: (pos: number) => string;
-                    charCodeAt: (index: number) => number;
-                    concat: (...strings: string[]) => string;
-                    indexOf: (searchString: string, position?: number) => number;
-                    lastIndexOf: (searchString: string, position?: number) => number;
-                    localeCompare: {
-                        (that: string): number;
-                        (that: string, locales?: string | string[], options?: Intl.CollatorOptions): number;
-                    };
-                    match: {
-                        (regexp: string | RegExp): RegExpMatchArray;
-                        (matcher: {
-                            [Symbol.match](string: string): RegExpMatchArray;
-                        }): RegExpMatchArray;
-                    };
-                    replace: {
-                        (searchValue: string | RegExp, replaceValue: string): string;
-                        (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string;
-                        (searchValue: {
-                            [Symbol.replace](string: string, replaceValue: string): string;
-                        }, replaceValue: string): string;
-                        (searchValue: {
-                            [Symbol.replace](string: string, replacer: (substring: string, ...args: any[]) => string): string;
-                        }, replacer: (substring: string, ...args: any[]) => string): string;
-                    };
-                    search: {
-                        (regexp: string | RegExp): number;
-                        (searcher: {
-                            [Symbol.search](string: string): number;
-                        }): number;
-                    };
-                    slice: (start?: number, end?: number) => string;
-                    split: {
-                        (separator: string | RegExp, limit?: number): string[];
-                        (splitter: {
-                            [Symbol.split](string: string, limit?: number): string[];
-                        }, limit?: number): string[];
-                    };
-                    substring: (start: number, end?: number) => string;
-                    toLowerCase: () => string;
-                    toLocaleLowerCase: (locales?: string | string[]) => string;
-                    toUpperCase: () => string;
-                    toLocaleUpperCase: (locales?: string | string[]) => string;
-                    trim: () => string;
-                    readonly length: number;
-                    substr: (from: number, length?: number) => string;
-                    valueOf: () => string;
-                    codePointAt: (pos: number) => number;
-                    includes: (searchString: string, position?: number) => boolean;
-                    endsWith: (searchString: string, endPosition?: number) => boolean;
-                    normalize: {
-                        (form: "NFC" | "NFD" | "NFKC" | "NFKD"): string;
-                        (form?: string): string;
-                    };
-                    repeat: (count: number) => string;
-                    startsWith: (searchString: string, position?: number) => boolean;
-                    anchor: (name: string) => string;
-                    big: () => string;
-                    blink: () => string;
-                    bold: () => string;
-                    fixed: () => string;
-                    fontcolor: (color: string) => string;
-                    fontsize: {
-                        (size: number): string;
-                        (size: string): string;
-                    };
-                    italics: () => string;
-                    link: (url: string) => string;
-                    small: () => string;
-                    strike: () => string;
-                    sub: () => string;
-                    sup: () => string;
-                    padStart: (maxLength: number, fillString?: string) => string;
-                    padEnd: (maxLength: number, fillString?: string) => string;
-                    trimEnd: () => string;
-                    trimStart: () => string;
-                    trimLeft: () => string;
-                    trimRight: () => string;
-                    matchAll: (regexp: RegExp) => IterableIterator<RegExpMatchArray>;
-                    [Symbol.iterator]: () => IterableIterator<string>;
-                    at: (index: number) => string;
+                render?: import("../../table/src/props").RenderFunctionString;
+                sort?: string | boolean | {
+                    sortFn?: Function;
+                    sortScope?: import("../../table/src/props").SortScope;
+                    value?: import("../../table/src/const").SORT_OPTION;
                 };
-                className?: string | Function;
-                align?: string;
-                prop?: string | Function;
-                index?: number;
+                filter?: string | boolean | {
+                    list: any[];
+                    filterFn?: Function;
+                    match?: import("../../table/src/props").FullEnum;
+                    checked?: any[];
+                    filterScope?: import("../../table/src/props").SortScope;
+                    btnSave?: string | boolean;
+                    btnReset?: string | boolean;
+                    height?: number;
+                    maxHeight?: number;
+                };
+                type?: "none" | "selection" | "index" | "expand";
+                label?: import("../../table/src/props").LabelFunctionString;
+                width?: string | number;
+                className?: import("../../table/src/props").RowClassFunctionString;
+                align?: "" | "right" | "left" | "center";
+                showOverflowTooltip?: boolean | {
+                    content: string | Function;
+                    disabled?: (col: import("../../bkui-vue").TableIColumn, row: any) => boolean;
+                    watchCellResize?: boolean;
+                    mode?: "auto" | "static";
+                    popoverOption?: any;
+                    resizerWay?: import("../../table/src/props").ResizerWay;
+                };
+                field: import("../../table/src/props").LabelFunctionString;
+                prop?: import("../../table/src/props").LabelFunctionString;
             };
         }, unknown, {}, {
             updateColumnDefine(unmounted?: boolean): void;
+            copyProps(props: Partial<import("vue").ExtractPropTypes<{
+                label: import("vue-types").VueTypeDef<import("../../table/src/props").LabelFunctionString>;
+                field: import("vue-types").VueTypeDef<import("../../table/src/props").LabelFunctionString>;
+                render: import("vue-types").VueTypeDef<import("../../table/src/props").RenderFunctionString>;
+                width: import("vue-types").VueTypeDef<string | number>;
+                minWidth: import("vue-types").VueTypeDef<string | number> & {
+                    default: string | number;
+                };
+                columnKey: import("vue-types").VueTypeValidableDef<string> & {
+                    default: string;
+                } & {
+                    default: string;
+                };
+                showOverflowTooltip: import("vue-types").VueTypeDef<import("../../table/src/props").IOverflowTooltipProp>;
+                type: import("vue-types").VueTypeDef<"none" | "selection" | "index" | "expand">;
+                resizable: import("vue-types").VueTypeValidableDef<boolean> & {
+                    default: boolean;
+                } & {
+                    default: boolean;
+                };
+                fixed: import("vue-types").VueTypeDef<boolean | "right" | "left"> & {
+                    default: boolean | "right" | "left";
+                };
+                sort: import("vue-types").VueTypeDef<import("../../table/src/props").ISortPropShape>;
+                filter: import("vue-types").VueTypeDef<import("../../table/src/props").IFilterPropShape>;
+                colspan: import("vue-types").VueTypeDef<import("../../table/src/props").SpanFunctionString> & {
+                    default: (({ column, colIndex, row, rowIndex }: {
+                        column: any;
+                        colIndex: any;
+                        row: any;
+                        rowIndex: any;
+                    }) => number) | (() => Number);
+                };
+                rowspan: import("vue-types").VueTypeDef<import("../../table/src/props").SpanFunctionString> & {
+                    default: (({ column, colIndex, row, rowIndex }: {
+                        column: any;
+                        colIndex: any;
+                        row: any;
+                        rowIndex: any;
+                    }) => number) | (() => Number);
+                };
+                align: import("vue-types").VueTypeDef<"" | "right" | "left" | "center">;
+                className: import("vue-types").VueTypeDef<import("../../table/src/props").RowClassFunctionString>;
+                prop: import("vue-types").VueTypeDef<import("../../table/src/props").LabelFunctionString>;
+                index: import("vue-types").VueTypeValidableDef<number> & {
+                    default: number;
+                } & {
+                    default: number;
+                };
+            }>>): {};
             updateColumnDefineByParent(): void;
-            updateColumnDefineByIndex(unmounted?: boolean): void;
+            unmountColumn(): void;
         }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
-            sort: string | boolean | {
-                sortFn: any;
-                sortScope: (object | "all" | "current" | (() => "all" | "current") | ((props: Record<string, unknown>) => "all" | "current")) & ("all" | "current");
-                value: string;
-            };
-            filter: string | boolean | {
-                list: any[] | (object & (() => any[]));
-                filterFn: any;
-                match: "full" | "fuzzy";
-                checked: any[] | (object & (() => any[]));
-                filterScope: (object | "all" | "current" | (() => "all" | "current") | ((props: Record<string, unknown>) => "all" | "current")) & ("all" | "current");
-                btnSave: (string | boolean | object | (() => string | boolean) | ((props: Record<string, unknown>) => string | boolean)) & (string | boolean);
-                btnReset: (string | boolean | object | (() => string | boolean) | ((props: Record<string, unknown>) => string | boolean)) & (string | boolean);
-            };
             fixed: boolean | "right" | "left";
             minWidth: string | number;
+            resizable: boolean;
             index: number;
             columnKey: string;
-            showOverflowTooltip: boolean | import("../../table/src/props").IOverflowTooltip;
-            resizable: boolean;
+            colspan: import("../../table/src/props").SpanFunctionString;
+            rowspan: import("../../table/src/props").SpanFunctionString;
         }, {}, string, {}> & {
             beforeCreate?: (() => void) | (() => void)[];
             created?: (() => void) | (() => void)[];
@@ -345,15 +287,9 @@ declare const BkTableColumn: {
         $nextTick: typeof import("vue").nextTick;
         $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
     } & Readonly<import("vue").ExtractPropTypes<{
-        prop: import("vue-types").VueTypeDef<any>;
-        index: import("vue-types").VueTypeValidableDef<number> & {
-            default: number;
-        } & {
-            default: number;
-        };
-        label: import("vue-types").VueTypeDef<any>;
-        field: import("vue-types").VueTypeDef<any>;
-        render: import("vue-types").VueTypeDef<any>;
+        label: import("vue-types").VueTypeDef<import("../../table/src/props").LabelFunctionString>;
+        field: import("vue-types").VueTypeDef<import("../../table/src/props").LabelFunctionString>;
+        render: import("vue-types").VueTypeDef<import("../../table/src/props").RenderFunctionString>;
         width: import("vue-types").VueTypeDef<string | number>;
         minWidth: import("vue-types").VueTypeDef<string | number> & {
             default: string | number;
@@ -363,9 +299,7 @@ declare const BkTableColumn: {
         } & {
             default: string;
         };
-        showOverflowTooltip: import("vue-types").VueTypeDef<boolean | import("../../table/src/props").IOverflowTooltip> & {
-            default: boolean | (() => import("../../table/src/props").IOverflowTooltip);
-        };
+        showOverflowTooltip: import("vue-types").VueTypeDef<import("../../table/src/props").IOverflowTooltipProp>;
         type: import("vue-types").VueTypeDef<"none" | "selection" | "index" | "expand">;
         resizable: import("vue-types").VueTypeValidableDef<boolean> & {
             default: boolean;
@@ -375,72 +309,49 @@ declare const BkTableColumn: {
         fixed: import("vue-types").VueTypeDef<boolean | "right" | "left"> & {
             default: boolean | "right" | "left";
         };
-        sort: import("vue-types").VueTypeDef<string | boolean | {
-            sortFn: any;
-            sortScope: (object | "all" | "current" | (() => "all" | "current") | ((props: Record<string, unknown>) => "all" | "current")) & ("all" | "current");
-            value: string;
-        }> & {
-            default: string | boolean | (() => {
-                sortFn: any;
-                sortScope: (object | "all" | "current" | (() => "all" | "current") | ((props: Record<string, unknown>) => "all" | "current")) & ("all" | "current");
-                value: string;
-            });
+        sort: import("vue-types").VueTypeDef<import("../../table/src/props").ISortPropShape>;
+        filter: import("vue-types").VueTypeDef<import("../../table/src/props").IFilterPropShape>;
+        colspan: import("vue-types").VueTypeDef<import("../../table/src/props").SpanFunctionString> & {
+            default: (({ column, colIndex, row, rowIndex }: {
+                column: any;
+                colIndex: any;
+                row: any;
+                rowIndex: any;
+            }) => number) | (() => Number);
         };
-        filter: import("vue-types").VueTypeDef<string | boolean | {
-            list: any[] | (object & (() => any[]));
-            filterFn: any;
-            match: "full" | "fuzzy";
-            checked: any[] | (object & (() => any[]));
-            filterScope: (object | "all" | "current" | (() => "all" | "current") | ((props: Record<string, unknown>) => "all" | "current")) & ("all" | "current");
-            btnSave: (string | boolean | object | (() => string | boolean) | ((props: Record<string, unknown>) => string | boolean)) & (string | boolean);
-            btnReset: (string | boolean | object | (() => string | boolean) | ((props: Record<string, unknown>) => string | boolean)) & (string | boolean);
-        }> & {
-            default: string | boolean | (() => {
-                list: any[] | (object & (() => any[]));
-                filterFn: any;
-                match: "full" | "fuzzy";
-                checked: any[] | (object & (() => any[]));
-                filterScope: (object | "all" | "current" | (() => "all" | "current") | ((props: Record<string, unknown>) => "all" | "current")) & ("all" | "current");
-                btnSave: (string | boolean | object | (() => string | boolean) | ((props: Record<string, unknown>) => string | boolean)) & (string | boolean);
-                btnReset: (string | boolean | object | (() => string | boolean) | ((props: Record<string, unknown>) => string | boolean)) & (string | boolean);
-            });
+        rowspan: import("vue-types").VueTypeDef<import("../../table/src/props").SpanFunctionString> & {
+            default: (({ column, colIndex, row, rowIndex }: {
+                column: any;
+                colIndex: any;
+                row: any;
+                rowIndex: any;
+            }) => number) | (() => Number);
         };
-        colspan: import("vue-types").VueTypeDef<any>;
-        rowspan: import("vue-types").VueTypeDef<any>;
         align: import("vue-types").VueTypeDef<"" | "right" | "left" | "center">;
-        className: import("vue-types").VueTypeDef<any>;
+        className: import("vue-types").VueTypeDef<import("../../table/src/props").RowClassFunctionString>;
+        prop: import("vue-types").VueTypeDef<import("../../table/src/props").LabelFunctionString>;
+        index: import("vue-types").VueTypeValidableDef<number> & {
+            default: number;
+        } & {
+            default: number;
+        };
     }>> & import("vue").ShallowUnwrapRef<{
-        initColumns: (_col: import("../../table/src/components/table-column").ITableColumn | import("../../table/src/components/table-column").ITableColumn[], _rm?: boolean) => void;
+        initColumns: (_col: import("../../bkui-vue").TableIColumn | import("../../bkui-vue").TableIColumn[], _rm?: boolean) => void;
         bkTableCache: {
             queueStack: (_: any, fn: any) => any;
         };
         column: {
-            field: string | Function;
-            label: string | Function;
-            render?: string | Function | import("vue").Slot<any>;
-            width?: string | number;
+            fixed?: boolean | "right" | "left";
             minWidth?: string | number;
-            columnKey?: string;
-            showOverflowTooltip?: boolean | {
-                content: string | Function;
-                disabled?: boolean;
-                watchCellResize?: boolean;
-                mode?: "auto" | "static";
-            };
-            type?: string;
-            fixed?: string | boolean;
             resizable?: boolean;
-            sort?: string | boolean | {
-                sortFn?: Function;
-                sortScope?: string;
-                value?: string;
-            };
-            filter?: string | boolean | {
-                list?: any;
-                filterFn?: Function;
-                checked?: any;
-            };
-            colspan?: Function | {
+            index?: number;
+            columnKey?: string;
+            colspan?: (({ column, colIndex, row, rowIndex }: {
+                column: any;
+                colIndex: any;
+                row: any;
+                rowIndex: any;
+            }) => number) | {
                 toString: (radix?: number) => string;
                 toFixed: (fractionDigits?: number) => string;
                 toExponential: (fractionDigits?: number) => string;
@@ -451,7 +362,12 @@ declare const BkTableColumn: {
                     (locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): string;
                 };
             };
-            rowspan?: Function | {
+            rowspan?: (({ column, colIndex, row, rowIndex }: {
+                column: any;
+                colIndex: any;
+                row: any;
+                rowIndex: any;
+            }) => number) | {
                 toString: (radix?: number) => string;
                 toFixed: (fractionDigits?: number) => string;
                 toExponential: (fractionDigits?: number) => string;
@@ -462,114 +378,101 @@ declare const BkTableColumn: {
                     (locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): string;
                 };
             };
-            textAlign?: {
-                [x: number]: string;
-                toString: () => string;
-                charAt: (pos: number) => string;
-                charCodeAt: (index: number) => number;
-                concat: (...strings: string[]) => string;
-                indexOf: (searchString: string, position?: number) => number;
-                lastIndexOf: (searchString: string, position?: number) => number;
-                localeCompare: {
-                    (that: string): number;
-                    (that: string, locales?: string | string[], options?: Intl.CollatorOptions): number;
-                };
-                match: {
-                    (regexp: string | RegExp): RegExpMatchArray;
-                    (matcher: {
-                        [Symbol.match](string: string): RegExpMatchArray;
-                    }): RegExpMatchArray;
-                };
-                replace: {
-                    (searchValue: string | RegExp, replaceValue: string): string;
-                    (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string;
-                    (searchValue: {
-                        [Symbol.replace](string: string, replaceValue: string): string;
-                    }, replaceValue: string): string;
-                    (searchValue: {
-                        [Symbol.replace](string: string, replacer: (substring: string, ...args: any[]) => string): string;
-                    }, replacer: (substring: string, ...args: any[]) => string): string;
-                };
-                search: {
-                    (regexp: string | RegExp): number;
-                    (searcher: {
-                        [Symbol.search](string: string): number;
-                    }): number;
-                };
-                slice: (start?: number, end?: number) => string;
-                split: {
-                    (separator: string | RegExp, limit?: number): string[];
-                    (splitter: {
-                        [Symbol.split](string: string, limit?: number): string[];
-                    }, limit?: number): string[];
-                };
-                substring: (start: number, end?: number) => string;
-                toLowerCase: () => string;
-                toLocaleLowerCase: (locales?: string | string[]) => string;
-                toUpperCase: () => string;
-                toLocaleUpperCase: (locales?: string | string[]) => string;
-                trim: () => string;
-                readonly length: number;
-                substr: (from: number, length?: number) => string;
-                valueOf: () => string;
-                codePointAt: (pos: number) => number;
-                includes: (searchString: string, position?: number) => boolean;
-                endsWith: (searchString: string, endPosition?: number) => boolean;
-                normalize: {
-                    (form: "NFC" | "NFD" | "NFKC" | "NFKD"): string;
-                    (form?: string): string;
-                };
-                repeat: (count: number) => string;
-                startsWith: (searchString: string, position?: number) => boolean;
-                anchor: (name: string) => string;
-                big: () => string;
-                blink: () => string;
-                bold: () => string;
-                fixed: () => string;
-                fontcolor: (color: string) => string;
-                fontsize: {
-                    (size: number): string;
-                    (size: string): string;
-                };
-                italics: () => string;
-                link: (url: string) => string;
-                small: () => string;
-                strike: () => string;
-                sub: () => string;
-                sup: () => string;
-                padStart: (maxLength: number, fillString?: string) => string;
-                padEnd: (maxLength: number, fillString?: string) => string;
-                trimEnd: () => string;
-                trimStart: () => string;
-                trimLeft: () => string;
-                trimRight: () => string;
-                matchAll: (regexp: RegExp) => IterableIterator<RegExpMatchArray>;
-                [Symbol.iterator]: () => IterableIterator<string>;
-                at: (index: number) => string;
+            render?: import("../../table/src/props").RenderFunctionString;
+            sort?: string | boolean | {
+                sortFn?: Function;
+                sortScope?: import("../../table/src/props").SortScope;
+                value?: import("../../table/src/const").SORT_OPTION;
             };
-            className?: string | Function;
-            align?: string;
-            prop?: string | Function;
-            index?: number;
+            filter?: string | boolean | {
+                list: any[];
+                filterFn?: Function;
+                match?: import("../../table/src/props").FullEnum;
+                checked?: any[];
+                filterScope?: import("../../table/src/props").SortScope;
+                btnSave?: string | boolean;
+                btnReset?: string | boolean;
+                height?: number;
+                maxHeight?: number;
+            };
+            type?: "none" | "selection" | "index" | "expand";
+            label?: import("../../table/src/props").LabelFunctionString;
+            width?: string | number;
+            className?: import("../../table/src/props").RowClassFunctionString;
+            align?: "" | "right" | "left" | "center";
+            showOverflowTooltip?: boolean | {
+                content: string | Function;
+                disabled?: (col: import("../../bkui-vue").TableIColumn, row: any) => boolean;
+                watchCellResize?: boolean;
+                mode?: "auto" | "static";
+                popoverOption?: any;
+                resizerWay?: import("../../table/src/props").ResizerWay;
+            };
+            field: import("../../table/src/props").LabelFunctionString;
+            prop?: import("../../table/src/props").LabelFunctionString;
         };
     }> & {} & {
         updateColumnDefine(unmounted?: boolean): void;
+        copyProps(props: Partial<import("vue").ExtractPropTypes<{
+            label: import("vue-types").VueTypeDef<import("../../table/src/props").LabelFunctionString>;
+            field: import("vue-types").VueTypeDef<import("../../table/src/props").LabelFunctionString>;
+            render: import("vue-types").VueTypeDef<import("../../table/src/props").RenderFunctionString>;
+            width: import("vue-types").VueTypeDef<string | number>;
+            minWidth: import("vue-types").VueTypeDef<string | number> & {
+                default: string | number;
+            };
+            columnKey: import("vue-types").VueTypeValidableDef<string> & {
+                default: string;
+            } & {
+                default: string;
+            };
+            showOverflowTooltip: import("vue-types").VueTypeDef<import("../../table/src/props").IOverflowTooltipProp>;
+            type: import("vue-types").VueTypeDef<"none" | "selection" | "index" | "expand">;
+            resizable: import("vue-types").VueTypeValidableDef<boolean> & {
+                default: boolean;
+            } & {
+                default: boolean;
+            };
+            fixed: import("vue-types").VueTypeDef<boolean | "right" | "left"> & {
+                default: boolean | "right" | "left";
+            };
+            sort: import("vue-types").VueTypeDef<import("../../table/src/props").ISortPropShape>;
+            filter: import("vue-types").VueTypeDef<import("../../table/src/props").IFilterPropShape>;
+            colspan: import("vue-types").VueTypeDef<import("../../table/src/props").SpanFunctionString> & {
+                default: (({ column, colIndex, row, rowIndex }: {
+                    column: any;
+                    colIndex: any;
+                    row: any;
+                    rowIndex: any;
+                }) => number) | (() => Number);
+            };
+            rowspan: import("vue-types").VueTypeDef<import("../../table/src/props").SpanFunctionString> & {
+                default: (({ column, colIndex, row, rowIndex }: {
+                    column: any;
+                    colIndex: any;
+                    row: any;
+                    rowIndex: any;
+                }) => number) | (() => Number);
+            };
+            align: import("vue-types").VueTypeDef<"" | "right" | "left" | "center">;
+            className: import("vue-types").VueTypeDef<import("../../table/src/props").RowClassFunctionString>;
+            prop: import("vue-types").VueTypeDef<import("../../table/src/props").LabelFunctionString>;
+            index: import("vue-types").VueTypeValidableDef<number> & {
+                default: number;
+            } & {
+                default: number;
+            };
+        }>>): {};
         updateColumnDefineByParent(): void;
-        updateColumnDefineByIndex(unmounted?: boolean): void;
+        unmountColumn(): void;
     } & import("vue").ComponentCustomProperties & {};
     __isFragment?: never;
     __isTeleport?: never;
     __isSuspense?: never;
 } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-    prop: import("vue-types").VueTypeDef<any>;
-    index: import("vue-types").VueTypeValidableDef<number> & {
-        default: number;
-    } & {
-        default: number;
-    };
-    label: import("vue-types").VueTypeDef<any>;
-    field: import("vue-types").VueTypeDef<any>;
-    render: import("vue-types").VueTypeDef<any>;
+    label: import("vue-types").VueTypeDef<import("../../table/src/props").LabelFunctionString>;
+    field: import("vue-types").VueTypeDef<import("../../table/src/props").LabelFunctionString>;
+    render: import("vue-types").VueTypeDef<import("../../table/src/props").RenderFunctionString>;
     width: import("vue-types").VueTypeDef<string | number>;
     minWidth: import("vue-types").VueTypeDef<string | number> & {
         default: string | number;
@@ -579,9 +482,7 @@ declare const BkTableColumn: {
     } & {
         default: string;
     };
-    showOverflowTooltip: import("vue-types").VueTypeDef<boolean | import("../../table/src/props").IOverflowTooltip> & {
-        default: boolean | (() => import("../../table/src/props").IOverflowTooltip);
-    };
+    showOverflowTooltip: import("vue-types").VueTypeDef<import("../../table/src/props").IOverflowTooltipProp>;
     type: import("vue-types").VueTypeDef<"none" | "selection" | "index" | "expand">;
     resizable: import("vue-types").VueTypeValidableDef<boolean> & {
         default: boolean;
@@ -591,72 +492,49 @@ declare const BkTableColumn: {
     fixed: import("vue-types").VueTypeDef<boolean | "right" | "left"> & {
         default: boolean | "right" | "left";
     };
-    sort: import("vue-types").VueTypeDef<string | boolean | {
-        sortFn: any;
-        sortScope: (object | "all" | "current" | (() => "all" | "current") | ((props: Record<string, unknown>) => "all" | "current")) & ("all" | "current");
-        value: string;
-    }> & {
-        default: string | boolean | (() => {
-            sortFn: any;
-            sortScope: (object | "all" | "current" | (() => "all" | "current") | ((props: Record<string, unknown>) => "all" | "current")) & ("all" | "current");
-            value: string;
-        });
+    sort: import("vue-types").VueTypeDef<import("../../table/src/props").ISortPropShape>;
+    filter: import("vue-types").VueTypeDef<import("../../table/src/props").IFilterPropShape>;
+    colspan: import("vue-types").VueTypeDef<import("../../table/src/props").SpanFunctionString> & {
+        default: (({ column, colIndex, row, rowIndex }: {
+            column: any;
+            colIndex: any;
+            row: any;
+            rowIndex: any;
+        }) => number) | (() => Number);
     };
-    filter: import("vue-types").VueTypeDef<string | boolean | {
-        list: any[] | (object & (() => any[]));
-        filterFn: any;
-        match: "full" | "fuzzy";
-        checked: any[] | (object & (() => any[]));
-        filterScope: (object | "all" | "current" | (() => "all" | "current") | ((props: Record<string, unknown>) => "all" | "current")) & ("all" | "current");
-        btnSave: (string | boolean | object | (() => string | boolean) | ((props: Record<string, unknown>) => string | boolean)) & (string | boolean);
-        btnReset: (string | boolean | object | (() => string | boolean) | ((props: Record<string, unknown>) => string | boolean)) & (string | boolean);
-    }> & {
-        default: string | boolean | (() => {
-            list: any[] | (object & (() => any[]));
-            filterFn: any;
-            match: "full" | "fuzzy";
-            checked: any[] | (object & (() => any[]));
-            filterScope: (object | "all" | "current" | (() => "all" | "current") | ((props: Record<string, unknown>) => "all" | "current")) & ("all" | "current");
-            btnSave: (string | boolean | object | (() => string | boolean) | ((props: Record<string, unknown>) => string | boolean)) & (string | boolean);
-            btnReset: (string | boolean | object | (() => string | boolean) | ((props: Record<string, unknown>) => string | boolean)) & (string | boolean);
-        });
+    rowspan: import("vue-types").VueTypeDef<import("../../table/src/props").SpanFunctionString> & {
+        default: (({ column, colIndex, row, rowIndex }: {
+            column: any;
+            colIndex: any;
+            row: any;
+            rowIndex: any;
+        }) => number) | (() => Number);
     };
-    colspan: import("vue-types").VueTypeDef<any>;
-    rowspan: import("vue-types").VueTypeDef<any>;
     align: import("vue-types").VueTypeDef<"" | "right" | "left" | "center">;
-    className: import("vue-types").VueTypeDef<any>;
+    className: import("vue-types").VueTypeDef<import("../../table/src/props").RowClassFunctionString>;
+    prop: import("vue-types").VueTypeDef<import("../../table/src/props").LabelFunctionString>;
+    index: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
 }>>, {
-    initColumns: (_col: import("../../table/src/components/table-column").ITableColumn | import("../../table/src/components/table-column").ITableColumn[], _rm?: boolean) => void;
+    initColumns: (_col: import("../../bkui-vue").TableIColumn | import("../../bkui-vue").TableIColumn[], _rm?: boolean) => void;
     bkTableCache: {
         queueStack: (_: any, fn: any) => any;
     };
     column: {
-        field: string | Function;
-        label: string | Function;
-        render?: string | Function | import("vue").Slot<any>;
-        width?: string | number;
+        fixed?: boolean | "right" | "left";
         minWidth?: string | number;
-        columnKey?: string;
-        showOverflowTooltip?: boolean | {
-            content: string | Function;
-            disabled?: boolean;
-            watchCellResize?: boolean;
-            mode?: "auto" | "static";
-        };
-        type?: string;
-        fixed?: string | boolean;
         resizable?: boolean;
-        sort?: string | boolean | {
-            sortFn?: Function;
-            sortScope?: string;
-            value?: string;
-        };
-        filter?: string | boolean | {
-            list?: any;
-            filterFn?: Function;
-            checked?: any;
-        };
-        colspan?: Function | {
+        index?: number;
+        columnKey?: string;
+        colspan?: (({ column, colIndex, row, rowIndex }: {
+            column: any;
+            colIndex: any;
+            row: any;
+            rowIndex: any;
+        }) => number) | {
             toString: (radix?: number) => string;
             toFixed: (fractionDigits?: number) => string;
             toExponential: (fractionDigits?: number) => string;
@@ -667,7 +545,12 @@ declare const BkTableColumn: {
                 (locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): string;
             };
         };
-        rowspan?: Function | {
+        rowspan?: (({ column, colIndex, row, rowIndex }: {
+            column: any;
+            colIndex: any;
+            row: any;
+            rowIndex: any;
+        }) => number) | {
             toString: (radix?: number) => string;
             toFixed: (fractionDigits?: number) => string;
             toExponential: (fractionDigits?: number) => string;
@@ -678,120 +561,100 @@ declare const BkTableColumn: {
                 (locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): string;
             };
         };
-        textAlign?: {
-            [x: number]: string;
-            toString: () => string;
-            charAt: (pos: number) => string;
-            charCodeAt: (index: number) => number;
-            concat: (...strings: string[]) => string;
-            indexOf: (searchString: string, position?: number) => number;
-            lastIndexOf: (searchString: string, position?: number) => number;
-            localeCompare: {
-                (that: string): number;
-                (that: string, locales?: string | string[], options?: Intl.CollatorOptions): number;
-            };
-            match: {
-                (regexp: string | RegExp): RegExpMatchArray;
-                (matcher: {
-                    [Symbol.match](string: string): RegExpMatchArray;
-                }): RegExpMatchArray;
-            };
-            replace: {
-                (searchValue: string | RegExp, replaceValue: string): string;
-                (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string;
-                (searchValue: {
-                    [Symbol.replace](string: string, replaceValue: string): string;
-                }, replaceValue: string): string;
-                (searchValue: {
-                    [Symbol.replace](string: string, replacer: (substring: string, ...args: any[]) => string): string;
-                }, replacer: (substring: string, ...args: any[]) => string): string;
-            };
-            search: {
-                (regexp: string | RegExp): number;
-                (searcher: {
-                    [Symbol.search](string: string): number;
-                }): number;
-            };
-            slice: (start?: number, end?: number) => string;
-            split: {
-                (separator: string | RegExp, limit?: number): string[];
-                (splitter: {
-                    [Symbol.split](string: string, limit?: number): string[];
-                }, limit?: number): string[];
-            };
-            substring: (start: number, end?: number) => string;
-            toLowerCase: () => string;
-            toLocaleLowerCase: (locales?: string | string[]) => string;
-            toUpperCase: () => string;
-            toLocaleUpperCase: (locales?: string | string[]) => string;
-            trim: () => string;
-            readonly length: number;
-            substr: (from: number, length?: number) => string;
-            valueOf: () => string;
-            codePointAt: (pos: number) => number;
-            includes: (searchString: string, position?: number) => boolean;
-            endsWith: (searchString: string, endPosition?: number) => boolean;
-            normalize: {
-                (form: "NFC" | "NFD" | "NFKC" | "NFKD"): string;
-                (form?: string): string;
-            };
-            repeat: (count: number) => string;
-            startsWith: (searchString: string, position?: number) => boolean;
-            anchor: (name: string) => string;
-            big: () => string;
-            blink: () => string;
-            bold: () => string;
-            fixed: () => string;
-            fontcolor: (color: string) => string;
-            fontsize: {
-                (size: number): string;
-                (size: string): string;
-            };
-            italics: () => string;
-            link: (url: string) => string;
-            small: () => string;
-            strike: () => string;
-            sub: () => string;
-            sup: () => string;
-            padStart: (maxLength: number, fillString?: string) => string;
-            padEnd: (maxLength: number, fillString?: string) => string;
-            trimEnd: () => string;
-            trimStart: () => string;
-            trimLeft: () => string;
-            trimRight: () => string;
-            matchAll: (regexp: RegExp) => IterableIterator<RegExpMatchArray>;
-            [Symbol.iterator]: () => IterableIterator<string>;
-            at: (index: number) => string;
+        render?: import("../../table/src/props").RenderFunctionString;
+        sort?: string | boolean | {
+            sortFn?: Function;
+            sortScope?: import("../../table/src/props").SortScope;
+            value?: import("../../table/src/const").SORT_OPTION;
         };
-        className?: string | Function;
-        align?: string;
-        prop?: string | Function;
-        index?: number;
+        filter?: string | boolean | {
+            list: any[];
+            filterFn?: Function;
+            match?: import("../../table/src/props").FullEnum;
+            checked?: any[];
+            filterScope?: import("../../table/src/props").SortScope;
+            btnSave?: string | boolean;
+            btnReset?: string | boolean;
+            height?: number;
+            maxHeight?: number;
+        };
+        type?: "none" | "selection" | "index" | "expand";
+        label?: import("../../table/src/props").LabelFunctionString;
+        width?: string | number;
+        className?: import("../../table/src/props").RowClassFunctionString;
+        align?: "" | "right" | "left" | "center";
+        showOverflowTooltip?: boolean | {
+            content: string | Function;
+            disabled?: (col: import("../../bkui-vue").TableIColumn, row: any) => boolean;
+            watchCellResize?: boolean;
+            mode?: "auto" | "static";
+            popoverOption?: any;
+            resizerWay?: import("../../table/src/props").ResizerWay;
+        };
+        field: import("../../table/src/props").LabelFunctionString;
+        prop?: import("../../table/src/props").LabelFunctionString;
     };
 }, unknown, {}, {
     updateColumnDefine(unmounted?: boolean): void;
+    copyProps(props: Partial<import("vue").ExtractPropTypes<{
+        label: import("vue-types").VueTypeDef<import("../../table/src/props").LabelFunctionString>;
+        field: import("vue-types").VueTypeDef<import("../../table/src/props").LabelFunctionString>;
+        render: import("vue-types").VueTypeDef<import("../../table/src/props").RenderFunctionString>;
+        width: import("vue-types").VueTypeDef<string | number>;
+        minWidth: import("vue-types").VueTypeDef<string | number> & {
+            default: string | number;
+        };
+        columnKey: import("vue-types").VueTypeValidableDef<string> & {
+            default: string;
+        } & {
+            default: string;
+        };
+        showOverflowTooltip: import("vue-types").VueTypeDef<import("../../table/src/props").IOverflowTooltipProp>;
+        type: import("vue-types").VueTypeDef<"none" | "selection" | "index" | "expand">;
+        resizable: import("vue-types").VueTypeValidableDef<boolean> & {
+            default: boolean;
+        } & {
+            default: boolean;
+        };
+        fixed: import("vue-types").VueTypeDef<boolean | "right" | "left"> & {
+            default: boolean | "right" | "left";
+        };
+        sort: import("vue-types").VueTypeDef<import("../../table/src/props").ISortPropShape>;
+        filter: import("vue-types").VueTypeDef<import("../../table/src/props").IFilterPropShape>;
+        colspan: import("vue-types").VueTypeDef<import("../../table/src/props").SpanFunctionString> & {
+            default: (({ column, colIndex, row, rowIndex }: {
+                column: any;
+                colIndex: any;
+                row: any;
+                rowIndex: any;
+            }) => number) | (() => Number);
+        };
+        rowspan: import("vue-types").VueTypeDef<import("../../table/src/props").SpanFunctionString> & {
+            default: (({ column, colIndex, row, rowIndex }: {
+                column: any;
+                colIndex: any;
+                row: any;
+                rowIndex: any;
+            }) => number) | (() => Number);
+        };
+        align: import("vue-types").VueTypeDef<"" | "right" | "left" | "center">;
+        className: import("vue-types").VueTypeDef<import("../../table/src/props").RowClassFunctionString>;
+        prop: import("vue-types").VueTypeDef<import("../../table/src/props").LabelFunctionString>;
+        index: import("vue-types").VueTypeValidableDef<number> & {
+            default: number;
+        } & {
+            default: number;
+        };
+    }>>): {};
     updateColumnDefineByParent(): void;
-    updateColumnDefineByIndex(unmounted?: boolean): void;
+    unmountColumn(): void;
 }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
-    sort: string | boolean | {
-        sortFn: any;
-        sortScope: (object | "all" | "current" | (() => "all" | "current") | ((props: Record<string, unknown>) => "all" | "current")) & ("all" | "current");
-        value: string;
-    };
-    filter: string | boolean | {
-        list: any[] | (object & (() => any[]));
-        filterFn: any;
-        match: "full" | "fuzzy";
-        checked: any[] | (object & (() => any[]));
-        filterScope: (object | "all" | "current" | (() => "all" | "current") | ((props: Record<string, unknown>) => "all" | "current")) & ("all" | "current");
-        btnSave: (string | boolean | object | (() => string | boolean) | ((props: Record<string, unknown>) => string | boolean)) & (string | boolean);
-        btnReset: (string | boolean | object | (() => string | boolean) | ((props: Record<string, unknown>) => string | boolean)) & (string | boolean);
-    };
     fixed: boolean | "right" | "left";
     minWidth: string | number;
+    resizable: boolean;
     index: number;
     columnKey: string;
-    showOverflowTooltip: boolean | import("../../table/src/props").IOverflowTooltip;
-    resizable: boolean;
+    colspan: import("../../table/src/props").SpanFunctionString;
+    rowspan: import("../../table/src/props").SpanFunctionString;
 }, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin<any[]>;
 export default BkTableColumn;