bkui-vue 0.0.1-beta.99 → 0.0.1

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

@@ -0,0 +1,797 @@
+declare const BkTableColumn: {
+    new (...args: any[]): {
+        $: 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;
+            index?: number;
+            columnKey?: string;
+            showOverflowTooltip?: boolean | import("../../table/src/props").IOverflowTooltip;
+            resizable?: boolean;
+            readonly type?: "none" | "selection" | "index" | "expand";
+            readonly render?: any;
+            class?: unknown;
+            readonly label?: any;
+            style?: unknown;
+            readonly width?: string | number;
+            key?: string | number | symbol;
+            ref?: import("vue").VNodeRef;
+            ref_for?: boolean;
+            ref_key?: string;
+            onVnodeBeforeMount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeMounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeBeforeUpdate?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeUpdated?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeBeforeUnmount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeUnmounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            readonly className?: any;
+            readonly align?: "" | "right" | "left" | "center";
+            readonly field?: any;
+            readonly colspan?: any;
+            readonly rowspan?: any;
+            readonly prop?: any;
+        };
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any>;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
+        $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>;
+            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<boolean | import("../../table/src/props").IOverflowTooltip> & {
+                default: boolean | (() => import("../../table/src/props").IOverflowTooltip);
+            };
+            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<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;
+                });
+            };
+            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);
+                });
+            };
+            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>;
+        }>>, {
+            initColumns: (_col: import("../../table/src/components/table-column").ITableColumn | import("../../table/src/components/table-column").ITableColumn[], _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;
+                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 | {
+                    toString: (radix?: number) => string;
+                    toFixed: (fractionDigits?: number) => string;
+                    toExponential: (fractionDigits?: number) => string;
+                    toPrecision: (precision?: number) => string;
+                    valueOf: () => number;
+                    toLocaleString: {
+                        (locales?: string | string[], options?: Intl.NumberFormatOptions): string;
+                        (locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): string;
+                    };
+                };
+                rowspan?: Function | {
+                    toString: (radix?: number) => string;
+                    toFixed: (fractionDigits?: number) => string;
+                    toExponential: (fractionDigits?: number) => string;
+                    toPrecision: (precision?: number) => string;
+                    valueOf: () => number;
+                    toLocaleString: {
+                        (locales?: string | string[], options?: Intl.NumberFormatOptions): string;
+                        (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;
+                };
+                className?: string | Function;
+                align?: string;
+                prop?: string | Function;
+                index?: number;
+            };
+        }, unknown, {}, {
+            updateColumnDefine(unmounted?: boolean): void;
+            updateColumnDefineByParent(): void;
+            updateColumnDefineByIndex(unmounted?: boolean): 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;
+            index: number;
+            columnKey: string;
+            showOverflowTooltip: boolean | import("../../table/src/props").IOverflowTooltip;
+            resizable: boolean;
+        }, {}, string, {}> & {
+            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: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $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>;
+        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<boolean | import("../../table/src/props").IOverflowTooltip> & {
+            default: boolean | (() => import("../../table/src/props").IOverflowTooltip);
+        };
+        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<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;
+            });
+        };
+        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);
+            });
+        };
+        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>;
+    }>> & import("vue").ShallowUnwrapRef<{
+        initColumns: (_col: import("../../table/src/components/table-column").ITableColumn | import("../../table/src/components/table-column").ITableColumn[], _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;
+            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 | {
+                toString: (radix?: number) => string;
+                toFixed: (fractionDigits?: number) => string;
+                toExponential: (fractionDigits?: number) => string;
+                toPrecision: (precision?: number) => string;
+                valueOf: () => number;
+                toLocaleString: {
+                    (locales?: string | string[], options?: Intl.NumberFormatOptions): string;
+                    (locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): string;
+                };
+            };
+            rowspan?: Function | {
+                toString: (radix?: number) => string;
+                toFixed: (fractionDigits?: number) => string;
+                toExponential: (fractionDigits?: number) => string;
+                toPrecision: (precision?: number) => string;
+                valueOf: () => number;
+                toLocaleString: {
+                    (locales?: string | string[], options?: Intl.NumberFormatOptions): string;
+                    (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;
+            };
+            className?: string | Function;
+            align?: string;
+            prop?: string | Function;
+            index?: number;
+        };
+    }> & {} & {
+        updateColumnDefine(unmounted?: boolean): void;
+        updateColumnDefineByParent(): void;
+        updateColumnDefineByIndex(unmounted?: boolean): 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>;
+    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<boolean | import("../../table/src/props").IOverflowTooltip> & {
+        default: boolean | (() => import("../../table/src/props").IOverflowTooltip);
+    };
+    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<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;
+        });
+    };
+    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);
+        });
+    };
+    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>;
+}>>, {
+    initColumns: (_col: import("../../table/src/components/table-column").ITableColumn | import("../../table/src/components/table-column").ITableColumn[], _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;
+        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 | {
+            toString: (radix?: number) => string;
+            toFixed: (fractionDigits?: number) => string;
+            toExponential: (fractionDigits?: number) => string;
+            toPrecision: (precision?: number) => string;
+            valueOf: () => number;
+            toLocaleString: {
+                (locales?: string | string[], options?: Intl.NumberFormatOptions): string;
+                (locales?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): string;
+            };
+        };
+        rowspan?: Function | {
+            toString: (radix?: number) => string;
+            toFixed: (fractionDigits?: number) => string;
+            toExponential: (fractionDigits?: number) => string;
+            toPrecision: (precision?: number) => string;
+            valueOf: () => number;
+            toLocaleString: {
+                (locales?: string | string[], options?: Intl.NumberFormatOptions): string;
+                (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;
+        };
+        className?: string | Function;
+        align?: string;
+        prop?: string | Function;
+        index?: number;
+    };
+}, unknown, {}, {
+    updateColumnDefine(unmounted?: boolean): void;
+    updateColumnDefineByParent(): void;
+    updateColumnDefineByIndex(unmounted?: boolean): 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;
+    index: number;
+    columnKey: string;
+    showOverflowTooltip: boolean | import("../../table/src/props").IOverflowTooltip;
+    resizable: boolean;
+}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin<any[]>;
+export default BkTableColumn;