@fangzhongya/fang-ui 0.0.29 → 0.0.30

package/dist/components/page/index.d.ts

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