yuang-framework-ui-pc 1.1.42 → 1.1.43

package/lib/ele-virtual-table/components/header-cell.d.ts

@@ -0,0 +1,3929 @@
+import { PropType } from 'vue';
+import { StyleValues } from '../../ele-app/types';
+import { Column, FilterValue, TableSize, HeaderCellClass, HeaderCellStyle } from '../../ele-data-table/types';
+import { HeaderColumn, SortBy, CellFilterChangeParams, CustomRenderProps, ColSize } from '../types';
+import { CellRender } from '../util';
+
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    /** 当前列配置 */
+    column: PropType<HeaderColumn>;
+    /** 当前列索引 */
+    columnIndex: NumberConstructor;
+    /** 当前行索引 */
+    headerIndex: NumberConstructor;
+    /** 当前列宽 */
+    colSize: PropType<ColSize>;
+    /** 表格排序状态 */
+    sortBy: PropType<SortBy>;
+    /** 表格当前筛选值 */
+    filterValue: PropType<FilterValue>;
+    /** 表格是否是全选状态 */
+    isCheckAll: BooleanConstructor;
+    /** 表格是否是半选状态 */
+    isIndeterminate: BooleanConstructor;
+    /** 是否禁用表头选择框 */
+    disabledCheckbox: BooleanConstructor;
+    /** 表格尺寸 */
+    tableSize: PropType<TableSize>;
+    /** 单元格类名自定义 */
+    headerCellClass: PropType<HeaderCellClass>;
+    /** 单元格样式自定义 */
+    headerCellStyle: PropType<HeaderCellStyle>;
+    /** 表头单元格是否溢出省略 */
+    headerEllipsis: BooleanConstructor;
+    /** 表格行高 */
+    rowHeight: NumberConstructor;
+}>, {
+    originalCol: import('vue').ComputedRef<Column | undefined>;
+    cellClass: import('vue').ComputedRef<string>;
+    cellStyle: import('vue').ComputedRef<StyleValues | undefined>;
+    cellTitle: import('vue').ComputedRef<string | undefined>;
+    renderOpt: import('vue').ComputedRef<CustomRenderProps>;
+    handleCheckedChange: (checked: boolean) => void;
+    handleFilterChange: (value: FilterValue) => void;
+    handleClick: (e: MouseEvent) => void;
+    handleContextmenu: (e: MouseEvent) => void;
+    handleMouseenter: (e: MouseEvent) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    /** 多选框选中改变事件 */
+    checkedChange: (_checked: boolean) => true;
+    /** 列筛选改变事件 */
+    filterChange: (_params: CellFilterChangeParams) => true;
+    /** 点击事件 */
+    click: (_col: Column, _e: MouseEvent) => true;
+    /** 右键事件 */
+    contextmenu: (_col: Column, _e: MouseEvent) => true;
+    /** 鼠标移入事件 */
+    mouseenter: (_col: Column, _e: MouseEvent) => true;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /** 当前列配置 */
+    column: PropType<HeaderColumn>;
+    /** 当前列索引 */
+    columnIndex: NumberConstructor;
+    /** 当前行索引 */
+    headerIndex: NumberConstructor;
+    /** 当前列宽 */
+    colSize: PropType<ColSize>;
+    /** 表格排序状态 */
+    sortBy: PropType<SortBy>;
+    /** 表格当前筛选值 */
+    filterValue: PropType<FilterValue>;
+    /** 表格是否是全选状态 */
+    isCheckAll: BooleanConstructor;
+    /** 表格是否是半选状态 */
+    isIndeterminate: BooleanConstructor;
+    /** 是否禁用表头选择框 */
+    disabledCheckbox: BooleanConstructor;
+    /** 表格尺寸 */
+    tableSize: PropType<TableSize>;
+    /** 单元格类名自定义 */
+    headerCellClass: PropType<HeaderCellClass>;
+    /** 单元格样式自定义 */
+    headerCellStyle: PropType<HeaderCellStyle>;
+    /** 表头单元格是否溢出省略 */
+    headerEllipsis: BooleanConstructor;
+    /** 表格行高 */
+    rowHeight: NumberConstructor;
+}>> & Readonly<{
+    onClick?: ((_col: Column, _e: MouseEvent) => any) | undefined;
+    onContextmenu?: ((_col: Column, _e: MouseEvent) => any) | undefined;
+    onMouseenter?: ((_col: Column, _e: MouseEvent) => any) | undefined;
+    onFilterChange?: ((_params: CellFilterChangeParams) => any) | undefined;
+    onCheckedChange?: ((_checked: boolean) => any) | undefined;
+}>, {
+    headerEllipsis: boolean;
+    isCheckAll: boolean;
+    isIndeterminate: boolean;
+    disabledCheckbox: boolean;
+}, {}, {
+    CellCheckbox: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        checked: BooleanConstructor;
+        indeterminate: BooleanConstructor;
+        disabled: BooleanConstructor;
+        size: PropType<TableSize>;
+    }>, {
+        handleUpdateModelValue: (modelValue: boolean) => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        change: (_checked: boolean) => true;
+    }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        checked: BooleanConstructor;
+        indeterminate: BooleanConstructor;
+        disabled: BooleanConstructor;
+        size: PropType<TableSize>;
+    }>> & Readonly<{
+        onChange?: ((_checked: boolean) => any) | undefined;
+    }>, {
+        disabled: boolean;
+        indeterminate: boolean;
+        checked: boolean;
+    }, {}, {
+        ElCheckbox: ({
+            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+                ariaControls: StringConstructor;
+                modelValue: {
+                    type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
+                    default: undefined;
+                };
+                label: {
+                    type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
+                    default: undefined;
+                };
+                value: {
+                    type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
+                    default: undefined;
+                };
+                indeterminate: BooleanConstructor;
+                disabled: BooleanConstructor;
+                checked: BooleanConstructor;
+                name: {
+                    type: StringConstructor;
+                    default: undefined;
+                };
+                trueValue: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                falseValue: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                trueLabel: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                falseLabel: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                id: {
+                    type: StringConstructor;
+                    default: undefined;
+                };
+                border: BooleanConstructor;
+                size: {
+                    readonly type: PropType<"" | "small" | "default" | "large">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                tabindex: (NumberConstructor | StringConstructor)[];
+                validateEvent: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & {
+                "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+            }, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                "update:modelValue": (val: import('element-plus').CheckboxValueType) => void;
+                change: (val: import('element-plus').CheckboxValueType) => void;
+            }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+                label: string | number | boolean | Record<string, any>;
+                disabled: boolean;
+                border: boolean;
+                value: string | number | boolean | Record<string, any>;
+                id: string;
+                name: string;
+                modelValue: string | number | boolean;
+                validateEvent: boolean;
+                indeterminate: boolean;
+                checked: boolean;
+                trueValue: string | number;
+                falseValue: string | number;
+                trueLabel: string | number;
+                falseLabel: string | number;
+            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import('vue').ExtractPropTypes<{
+                ariaControls: StringConstructor;
+                modelValue: {
+                    type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
+                    default: undefined;
+                };
+                label: {
+                    type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
+                    default: undefined;
+                };
+                value: {
+                    type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
+                    default: undefined;
+                };
+                indeterminate: BooleanConstructor;
+                disabled: BooleanConstructor;
+                checked: BooleanConstructor;
+                name: {
+                    type: StringConstructor;
+                    default: undefined;
+                };
+                trueValue: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                falseValue: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                trueLabel: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                falseLabel: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                id: {
+                    type: StringConstructor;
+                    default: undefined;
+                };
+                border: BooleanConstructor;
+                size: {
+                    readonly type: PropType<"" | "small" | "default" | "large">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                tabindex: (NumberConstructor | StringConstructor)[];
+                validateEvent: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & {
+                "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+            }, {}, {}, {}, {}, {
+                label: string | number | boolean | Record<string, any>;
+                disabled: boolean;
+                border: boolean;
+                value: string | number | boolean | Record<string, any>;
+                id: string;
+                name: string;
+                modelValue: string | number | boolean;
+                validateEvent: boolean;
+                indeterminate: boolean;
+                checked: boolean;
+                trueValue: string | number;
+                falseValue: string | number;
+                trueLabel: string | number;
+                falseLabel: string | number;
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+            ariaControls: StringConstructor;
+            modelValue: {
+                type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
+                default: undefined;
+            };
+            label: {
+                type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
+                default: undefined;
+            };
+            value: {
+                type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
+                default: undefined;
+            };
+            indeterminate: BooleanConstructor;
+            disabled: BooleanConstructor;
+            checked: BooleanConstructor;
+            name: {
+                type: StringConstructor;
+                default: undefined;
+            };
+            trueValue: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            falseValue: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            trueLabel: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            falseLabel: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            id: {
+                type: StringConstructor;
+                default: undefined;
+            };
+            border: BooleanConstructor;
+            size: {
+                readonly type: PropType<"" | "small" | "default" | "large">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            tabindex: (NumberConstructor | StringConstructor)[];
+            validateEvent: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & {
+            "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+            onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+        }, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            "update:modelValue": (val: import('element-plus').CheckboxValueType) => void;
+            change: (val: import('element-plus').CheckboxValueType) => void;
+        }, string, {
+            label: string | number | boolean | Record<string, any>;
+            disabled: boolean;
+            border: boolean;
+            value: string | number | boolean | Record<string, any>;
+            id: string;
+            name: string;
+            modelValue: string | number | boolean;
+            validateEvent: boolean;
+            indeterminate: boolean;
+            checked: boolean;
+            trueValue: string | number;
+            falseValue: string | number;
+            trueLabel: string | number;
+            falseLabel: string | number;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) & import('vue').Plugin) & {
+            CheckboxButton: {
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+                    ariaControls: StringConstructor;
+                    modelValue: {
+                        type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
+                        default: undefined;
+                    };
+                    label: {
+                        type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
+                        default: undefined;
+                    };
+                    value: {
+                        type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
+                        default: undefined;
+                    };
+                    indeterminate: BooleanConstructor;
+                    disabled: BooleanConstructor;
+                    checked: BooleanConstructor;
+                    name: {
+                        type: StringConstructor;
+                        default: undefined;
+                    };
+                    trueValue: {
+                        type: (NumberConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    falseValue: {
+                        type: (NumberConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    trueLabel: {
+                        type: (NumberConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    falseLabel: {
+                        type: (NumberConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    id: {
+                        type: StringConstructor;
+                        default: undefined;
+                    };
+                    border: BooleanConstructor;
+                    size: {
+                        readonly type: PropType<"" | "small" | "default" | "large">;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    tabindex: (NumberConstructor | StringConstructor)[];
+                    validateEvent: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & {
+                    "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                    onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                }, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    "update:modelValue": (val: import('element-plus').CheckboxValueType) => void;
+                    change: (val: import('element-plus').CheckboxValueType) => void;
+                }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+                    label: string | number | boolean | Record<string, any>;
+                    disabled: boolean;
+                    border: boolean;
+                    value: string | number | boolean | Record<string, any>;
+                    id: string;
+                    name: string;
+                    modelValue: string | number | boolean;
+                    validateEvent: boolean;
+                    indeterminate: boolean;
+                    checked: boolean;
+                    trueValue: string | number;
+                    falseValue: string | number;
+                    trueLabel: string | number;
+                    falseLabel: string | number;
+                }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('vue').ExtractPropTypes<{
+                    ariaControls: StringConstructor;
+                    modelValue: {
+                        type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
+                        default: undefined;
+                    };
+                    label: {
+                        type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
+                        default: undefined;
+                    };
+                    value: {
+                        type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
+                        default: undefined;
+                    };
+                    indeterminate: BooleanConstructor;
+                    disabled: BooleanConstructor;
+                    checked: BooleanConstructor;
+                    name: {
+                        type: StringConstructor;
+                        default: undefined;
+                    };
+                    trueValue: {
+                        type: (NumberConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    falseValue: {
+                        type: (NumberConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    trueLabel: {
+                        type: (NumberConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    falseLabel: {
+                        type: (NumberConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    id: {
+                        type: StringConstructor;
+                        default: undefined;
+                    };
+                    border: BooleanConstructor;
+                    size: {
+                        readonly type: PropType<"" | "small" | "default" | "large">;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    tabindex: (NumberConstructor | StringConstructor)[];
+                    validateEvent: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & {
+                    "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                    onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                }, {}, {}, {}, {}, {
+                    label: string | number | boolean | Record<string, any>;
+                    disabled: boolean;
+                    border: boolean;
+                    value: string | number | boolean | Record<string, any>;
+                    id: string;
+                    name: string;
+                    modelValue: string | number | boolean;
+                    validateEvent: boolean;
+                    indeterminate: boolean;
+                    checked: boolean;
+                    trueValue: string | number;
+                    falseValue: string | number;
+                    trueLabel: string | number;
+                    falseLabel: string | number;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                ariaControls: StringConstructor;
+                modelValue: {
+                    type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
+                    default: undefined;
+                };
+                label: {
+                    type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
+                    default: undefined;
+                };
+                value: {
+                    type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
+                    default: undefined;
+                };
+                indeterminate: BooleanConstructor;
+                disabled: BooleanConstructor;
+                checked: BooleanConstructor;
+                name: {
+                    type: StringConstructor;
+                    default: undefined;
+                };
+                trueValue: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                falseValue: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                trueLabel: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                falseLabel: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                id: {
+                    type: StringConstructor;
+                    default: undefined;
+                };
+                border: BooleanConstructor;
+                size: {
+                    readonly type: PropType<"" | "small" | "default" | "large">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                tabindex: (NumberConstructor | StringConstructor)[];
+                validateEvent: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & {
+                "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+            }, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                "update:modelValue": (val: import('element-plus').CheckboxValueType) => void;
+                change: (val: import('element-plus').CheckboxValueType) => void;
+            }, string, {
+                label: string | number | boolean | Record<string, any>;
+                disabled: boolean;
+                border: boolean;
+                value: string | number | boolean | Record<string, any>;
+                id: string;
+                name: string;
+                modelValue: string | number | boolean;
+                validateEvent: boolean;
+                indeterminate: boolean;
+                checked: boolean;
+                trueValue: string | number;
+                falseValue: string | number;
+                trueLabel: string | number;
+                falseLabel: string | number;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    default?(_: {}): any;
+                };
+            });
+            CheckboxGroup: {
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+                    readonly ariaLabel: StringConstructor;
+                    readonly modelValue: {
+                        readonly type: PropType<import('element-plus').CheckboxGroupValueType>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: () => never[];
+                    };
+                    readonly disabled: BooleanConstructor;
+                    readonly min: NumberConstructor;
+                    readonly max: NumberConstructor;
+                    readonly size: {
+                        readonly type: PropType<"" | "small" | "default" | "large">;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly fill: StringConstructor;
+                    readonly textColor: StringConstructor;
+                    readonly tag: {
+                        readonly type: PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "div";
+                    };
+                    readonly validateEvent: {
+                        readonly type: PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: true;
+                    };
+                }>> & {
+                    "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxGroupValueType) => any) | undefined;
+                    onChange?: ((val: import('element-plus').CheckboxValueType[]) => any) | undefined;
+                }, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    "update:modelValue": (val: import('element-plus').CheckboxGroupValueType) => void;
+                    change: (val: import('element-plus').CheckboxValueType[]) => void;
+                }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+                    readonly disabled: boolean;
+                    readonly modelValue: import('element-plus').CheckboxGroupValueType;
+                    readonly validateEvent: boolean;
+                    readonly tag: string;
+                }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('vue').ExtractPropTypes<{
+                    readonly ariaLabel: StringConstructor;
+                    readonly modelValue: {
+                        readonly type: PropType<import('element-plus').CheckboxGroupValueType>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: () => never[];
+                    };
+                    readonly disabled: BooleanConstructor;
+                    readonly min: NumberConstructor;
+                    readonly max: NumberConstructor;
+                    readonly size: {
+                        readonly type: PropType<"" | "small" | "default" | "large">;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly fill: StringConstructor;
+                    readonly textColor: StringConstructor;
+                    readonly tag: {
+                        readonly type: PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "div";
+                    };
+                    readonly validateEvent: {
+                        readonly type: PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: true;
+                    };
+                }>> & {
+                    "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxGroupValueType) => any) | undefined;
+                    onChange?: ((val: import('element-plus').CheckboxValueType[]) => any) | undefined;
+                }, {}, {}, {}, {}, {
+                    readonly disabled: boolean;
+                    readonly modelValue: import('element-plus').CheckboxGroupValueType;
+                    readonly validateEvent: boolean;
+                    readonly tag: string;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                readonly ariaLabel: StringConstructor;
+                readonly modelValue: {
+                    readonly type: PropType<import('element-plus').CheckboxGroupValueType>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => never[];
+                };
+                readonly disabled: BooleanConstructor;
+                readonly min: NumberConstructor;
+                readonly max: NumberConstructor;
+                readonly size: {
+                    readonly type: PropType<"" | "small" | "default" | "large">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly fill: StringConstructor;
+                readonly textColor: StringConstructor;
+                readonly tag: {
+                    readonly type: PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "div";
+                };
+                readonly validateEvent: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+            }>> & {
+                "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxGroupValueType) => any) | undefined;
+                onChange?: ((val: import('element-plus').CheckboxValueType[]) => any) | undefined;
+            }, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                "update:modelValue": (val: import('element-plus').CheckboxGroupValueType) => void;
+                change: (val: import('element-plus').CheckboxValueType[]) => void;
+            }, string, {
+                readonly disabled: boolean;
+                readonly modelValue: import('element-plus').CheckboxGroupValueType;
+                readonly validateEvent: boolean;
+                readonly tag: string;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    default?(_: {}): any;
+                };
+            });
+        };
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    CellFilter: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        filtered: PropType<FilterValue>;
+        filterMultiple: BooleanConstructor;
+        filters: PropType<Column["filters"]>;
+        filterPlacement: {
+            type: PropType<import('../../ele-app/plus').EleTooltipProps["placement"]>;
+            default: string;
+        };
+    }>, {
+        popperRef: import('vue').Ref<import('../../ele-app/plus').EleTooltipInstance, import('../../ele-app/plus').EleTooltipInstance>;
+        checkedValue: import('vue').Ref<string[], string[]>;
+        clearFilterText: import('vue').ComputedRef<string>;
+        filteredValue: import('vue').ComputedRef<string | undefined>;
+        confirmText: import('vue').ComputedRef<string>;
+        resetText: import('vue').ComputedRef<string>;
+        handleItemClick: (value?: string) => void;
+        handleFilterChange: (filtered: FilterValue) => void;
+        handleConfirm: () => void;
+        handleReset: () => void;
+        handleBeforeEnter: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        change: (_filtered: FilterValue) => true;
+    }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        filtered: PropType<FilterValue>;
+        filterMultiple: BooleanConstructor;
+        filters: PropType<Column["filters"]>;
+        filterPlacement: {
+            type: PropType<import('../../ele-app/plus').EleTooltipProps["placement"]>;
+            default: string;
+        };
+    }>> & Readonly<{
+        onChange?: ((_filtered: FilterValue) => any) | undefined;
+    }>, {
+        filterPlacement: string | undefined;
+        filterMultiple: boolean;
+    }, {}, {
+        ElIcon: {
+            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+                readonly size: {
+                    readonly type: PropType<string | number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly color: {
+                    readonly type: PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+            }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import('vue').ExtractPropTypes<{
+                readonly size: {
+                    readonly type: PropType<string | number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly color: {
+                    readonly type: PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+            }>>, {}, {}, {}, {}, {}>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+            readonly size: {
+                readonly type: PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly color: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) & import('vue').Plugin;
+        ElButton: ({
+            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+                readonly size: {
+                    readonly type: PropType<"" | "small" | "default" | "large">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly disabled: BooleanConstructor;
+                readonly type: {
+                    readonly type: PropType<"" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly icon: {
+                    readonly type: PropType<string | import('vue').Component>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly nativeType: {
+                    readonly type: PropType<"button" | "reset" | "submit">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "button";
+                };
+                readonly loading: BooleanConstructor;
+                readonly loadingIcon: {
+                    readonly type: PropType<string | import('vue').Component>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => any;
+                };
+                readonly plain: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: undefined;
+                };
+                readonly text: BooleanConstructor;
+                readonly link: BooleanConstructor;
+                readonly bg: BooleanConstructor;
+                readonly autofocus: BooleanConstructor;
+                readonly round: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: undefined;
+                };
+                readonly circle: BooleanConstructor;
+                readonly color: StringConstructor;
+                readonly dark: BooleanConstructor;
+                readonly autoInsertSpace: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: undefined;
+                };
+                readonly tag: {
+                    readonly type: PropType<string | import('vue').Component>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "button";
+                };
+            }>> & {
+                onClick?: ((evt: MouseEvent) => any) | undefined;
+            }, {
+                ref: import('vue').Ref<HTMLButtonElement | undefined>;
+                size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
+                type: import('vue').ComputedRef<string>;
+                disabled: import('vue').ComputedRef<boolean>;
+                shouldAddSpace: import('vue').ComputedRef<boolean>;
+            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                click: (evt: MouseEvent) => void;
+            }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+                readonly link: boolean;
+                readonly circle: boolean;
+                readonly text: boolean;
+                readonly disabled: boolean;
+                readonly round: boolean;
+                readonly dark: boolean;
+                readonly type: "" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text";
+                readonly bg: boolean;
+                readonly loading: boolean;
+                readonly autofocus: boolean;
+                readonly tag: string | import('vue').Component;
+                readonly plain: boolean;
+                readonly nativeType: "button" | "reset" | "submit";
+                readonly loadingIcon: string | import('vue').Component;
+                readonly autoInsertSpace: boolean;
+            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import('vue').ExtractPropTypes<{
+                readonly size: {
+                    readonly type: PropType<"" | "small" | "default" | "large">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly disabled: BooleanConstructor;
+                readonly type: {
+                    readonly type: PropType<"" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly icon: {
+                    readonly type: PropType<string | import('vue').Component>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly nativeType: {
+                    readonly type: PropType<"button" | "reset" | "submit">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "button";
+                };
+                readonly loading: BooleanConstructor;
+                readonly loadingIcon: {
+                    readonly type: PropType<string | import('vue').Component>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => any;
+                };
+                readonly plain: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: undefined;
+                };
+                readonly text: BooleanConstructor;
+                readonly link: BooleanConstructor;
+                readonly bg: BooleanConstructor;
+                readonly autofocus: BooleanConstructor;
+                readonly round: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: undefined;
+                };
+                readonly circle: BooleanConstructor;
+                readonly color: StringConstructor;
+                readonly dark: BooleanConstructor;
+                readonly autoInsertSpace: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: undefined;
+                };
+                readonly tag: {
+                    readonly type: PropType<string | import('vue').Component>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "button";
+                };
+            }>> & {
+                onClick?: ((evt: MouseEvent) => any) | undefined;
+            }, {
+                ref: import('vue').Ref<HTMLButtonElement | undefined>;
+                size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
+                type: import('vue').ComputedRef<string>;
+                disabled: import('vue').ComputedRef<boolean>;
+                shouldAddSpace: import('vue').ComputedRef<boolean>;
+            }, {}, {}, {}, {
+                readonly link: boolean;
+                readonly circle: boolean;
+                readonly text: boolean;
+                readonly disabled: boolean;
+                readonly round: boolean;
+                readonly dark: boolean;
+                readonly type: "" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text";
+                readonly bg: boolean;
+                readonly loading: boolean;
+                readonly autofocus: boolean;
+                readonly tag: string | import('vue').Component;
+                readonly plain: boolean;
+                readonly nativeType: "button" | "reset" | "submit";
+                readonly loadingIcon: string | import('vue').Component;
+                readonly autoInsertSpace: boolean;
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+            readonly size: {
+                readonly type: PropType<"" | "small" | "default" | "large">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly disabled: BooleanConstructor;
+            readonly type: {
+                readonly type: PropType<"" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly icon: {
+                readonly type: PropType<string | import('vue').Component>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly nativeType: {
+                readonly type: PropType<"button" | "reset" | "submit">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "button";
+            };
+            readonly loading: BooleanConstructor;
+            readonly loadingIcon: {
+                readonly type: PropType<string | import('vue').Component>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => any;
+            };
+            readonly plain: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            readonly text: BooleanConstructor;
+            readonly link: BooleanConstructor;
+            readonly bg: BooleanConstructor;
+            readonly autofocus: BooleanConstructor;
+            readonly round: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            readonly circle: BooleanConstructor;
+            readonly color: StringConstructor;
+            readonly dark: BooleanConstructor;
+            readonly autoInsertSpace: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            readonly tag: {
+                readonly type: PropType<string | import('vue').Component>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "button";
+            };
+        }>> & {
+            onClick?: ((evt: MouseEvent) => any) | undefined;
+        }, {
+            ref: import('vue').Ref<HTMLButtonElement | undefined>;
+            size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
+            type: import('vue').ComputedRef<string>;
+            disabled: import('vue').ComputedRef<boolean>;
+            shouldAddSpace: import('vue').ComputedRef<boolean>;
+        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            click: (evt: MouseEvent) => void;
+        }, string, {
+            readonly link: boolean;
+            readonly circle: boolean;
+            readonly text: boolean;
+            readonly disabled: boolean;
+            readonly round: boolean;
+            readonly dark: boolean;
+            readonly type: "" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text";
+            readonly bg: boolean;
+            readonly loading: boolean;
+            readonly autofocus: boolean;
+            readonly tag: string | import('vue').Component;
+            readonly plain: boolean;
+            readonly nativeType: "button" | "reset" | "submit";
+            readonly loadingIcon: string | import('vue').Component;
+            readonly autoInsertSpace: boolean;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+            $slots: {
+                loading?(_: {}): any;
+                icon?(_: {}): any;
+                default?(_: {}): any;
+            };
+        }) & import('vue').Plugin) & {
+            ButtonGroup: {
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+                    readonly size: {
+                        readonly type: PropType<"" | "small" | "default" | "large">;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly type: {
+                        readonly type: PropType<"" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text">;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "";
+                    };
+                }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+                    readonly type: "" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text";
+                }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('vue').ExtractPropTypes<{
+                    readonly size: {
+                        readonly type: PropType<"" | "small" | "default" | "large">;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly type: {
+                        readonly type: PropType<"" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text">;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "";
+                    };
+                }>>, {}, {}, {}, {}, {
+                    readonly type: "" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text";
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                readonly size: {
+                    readonly type: PropType<"" | "small" | "default" | "large">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly type: {
+                    readonly type: PropType<"" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+            }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
+                readonly type: "" | "success" | "primary" | "warning" | "info" | "default" | "danger" | "text";
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    default?(_: {}): any;
+                };
+            });
+        };
+        ElScrollbar: {
+            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+                readonly ariaLabel: StringConstructor;
+                readonly ariaOrientation: {
+                    readonly type: PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly height: {
+                    readonly type: PropType<string | number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly maxHeight: {
+                    readonly type: PropType<string | number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly native: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: false;
+                };
+                readonly wrapStyle: {
+                    readonly type: PropType<import('vue').StyleValue>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly wrapClass: {
+                    readonly type: PropType<string | unknown[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly viewClass: {
+                    readonly type: PropType<string | unknown[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly viewStyle: {
+                    readonly type: PropType<string | Record<string, any> | unknown[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly noresize: BooleanConstructor;
+                readonly tag: {
+                    readonly type: PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "div";
+                };
+                readonly always: BooleanConstructor;
+                readonly minSize: {
+                    readonly type: PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 20;
+                };
+                readonly tabindex: {
+                    readonly type: PropType<string | number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: undefined;
+                };
+                readonly id: StringConstructor;
+                readonly role: StringConstructor;
+            }>> & {
+                onScroll?: ((args_0: {
+                    scrollTop: number;
+                    scrollLeft: number;
+                }) => any) | undefined;
+                "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
+            }, {
+                wrapRef: import('vue').Ref<HTMLDivElement | undefined>;
+                update: () => void;
+                scrollTo: {
+                    (xCord: number, yCord?: number): void;
+                    (options: ScrollToOptions): void;
+                };
+                setScrollTop: (value: number) => void;
+                setScrollLeft: (value: number) => void;
+                handleScroll: () => void;
+            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                scroll: (args_0: {
+                    scrollTop: number;
+                    scrollLeft: number;
+                }) => void;
+                "end-reached": (direction: import('element-plus').ScrollbarDirection) => void;
+            }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+                readonly height: string | number;
+                readonly maxHeight: string | number;
+                readonly always: boolean;
+                readonly tabindex: string | number;
+                readonly minSize: number;
+                readonly native: boolean;
+                readonly wrapStyle: import('vue').StyleValue;
+                readonly wrapClass: string | unknown[];
+                readonly viewClass: string | unknown[];
+                readonly viewStyle: string | Record<string, any> | unknown[];
+                readonly tag: string;
+                readonly noresize: boolean;
+            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import('vue').ExtractPropTypes<{
+                readonly ariaLabel: StringConstructor;
+                readonly ariaOrientation: {
+                    readonly type: PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly height: {
+                    readonly type: PropType<string | number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly maxHeight: {
+                    readonly type: PropType<string | number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly native: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: false;
+                };
+                readonly wrapStyle: {
+                    readonly type: PropType<import('vue').StyleValue>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly wrapClass: {
+                    readonly type: PropType<string | unknown[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly viewClass: {
+                    readonly type: PropType<string | unknown[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly viewStyle: {
+                    readonly type: PropType<string | Record<string, any> | unknown[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly noresize: BooleanConstructor;
+                readonly tag: {
+                    readonly type: PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "div";
+                };
+                readonly always: BooleanConstructor;
+                readonly minSize: {
+                    readonly type: PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 20;
+                };
+                readonly tabindex: {
+                    readonly type: PropType<string | number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: undefined;
+                };
+                readonly id: StringConstructor;
+                readonly role: StringConstructor;
+            }>> & {
+                onScroll?: ((args_0: {
+                    scrollTop: number;
+                    scrollLeft: number;
+                }) => any) | undefined;
+                "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
+            }, {
+                wrapRef: import('vue').Ref<HTMLDivElement | undefined>;
+                update: () => void;
+                scrollTo: {
+                    (xCord: number, yCord?: number): void;
+                    (options: ScrollToOptions): void;
+                };
+                setScrollTop: (value: number) => void;
+                setScrollLeft: (value: number) => void;
+                handleScroll: () => void;
+            }, {}, {}, {}, {
+                readonly height: string | number;
+                readonly maxHeight: string | number;
+                readonly always: boolean;
+                readonly tabindex: string | number;
+                readonly minSize: number;
+                readonly native: boolean;
+                readonly wrapStyle: import('vue').StyleValue;
+                readonly wrapClass: string | unknown[];
+                readonly viewClass: string | unknown[];
+                readonly viewStyle: string | Record<string, any> | unknown[];
+                readonly tag: string;
+                readonly noresize: boolean;
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+            readonly ariaLabel: StringConstructor;
+            readonly ariaOrientation: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly height: {
+                readonly type: PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly maxHeight: {
+                readonly type: PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly native: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: false;
+            };
+            readonly wrapStyle: {
+                readonly type: PropType<import('vue').StyleValue>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly wrapClass: {
+                readonly type: PropType<string | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly viewClass: {
+                readonly type: PropType<string | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly viewStyle: {
+                readonly type: PropType<string | Record<string, any> | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly noresize: BooleanConstructor;
+            readonly tag: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "div";
+            };
+            readonly always: BooleanConstructor;
+            readonly minSize: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 20;
+            };
+            readonly tabindex: {
+                readonly type: PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            readonly id: StringConstructor;
+            readonly role: StringConstructor;
+        }>> & {
+            onScroll?: ((args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => any) | undefined;
+            "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
+        }, {
+            wrapRef: import('vue').Ref<HTMLDivElement | undefined>;
+            update: () => void;
+            scrollTo: {
+                (xCord: number, yCord?: number): void;
+                (options: ScrollToOptions): void;
+            };
+            setScrollTop: (value: number) => void;
+            setScrollLeft: (value: number) => void;
+            handleScroll: () => void;
+        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            scroll: (args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => void;
+            "end-reached": (direction: import('element-plus').ScrollbarDirection) => void;
+        }, string, {
+            readonly height: string | number;
+            readonly maxHeight: string | number;
+            readonly always: boolean;
+            readonly tabindex: string | number;
+            readonly minSize: number;
+            readonly native: boolean;
+            readonly wrapStyle: import('vue').StyleValue;
+            readonly wrapClass: string | unknown[];
+            readonly viewClass: string | unknown[];
+            readonly viewStyle: string | Record<string, any> | unknown[];
+            readonly tag: string;
+            readonly noresize: boolean;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) & import('vue').Plugin;
+        ElCheckboxGroup: {
+            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+                readonly ariaLabel: StringConstructor;
+                readonly modelValue: {
+                    readonly type: PropType<import('element-plus').CheckboxGroupValueType>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => never[];
+                };
+                readonly disabled: BooleanConstructor;
+                readonly min: NumberConstructor;
+                readonly max: NumberConstructor;
+                readonly size: {
+                    readonly type: PropType<"" | "small" | "default" | "large">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly fill: StringConstructor;
+                readonly textColor: StringConstructor;
+                readonly tag: {
+                    readonly type: PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "div";
+                };
+                readonly validateEvent: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+            }>> & {
+                "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxGroupValueType) => any) | undefined;
+                onChange?: ((val: import('element-plus').CheckboxValueType[]) => any) | undefined;
+            }, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                "update:modelValue": (val: import('element-plus').CheckboxGroupValueType) => void;
+                change: (val: import('element-plus').CheckboxValueType[]) => void;
+            }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+                readonly disabled: boolean;
+                readonly modelValue: import('element-plus').CheckboxGroupValueType;
+                readonly validateEvent: boolean;
+                readonly tag: string;
+            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import('vue').ExtractPropTypes<{
+                readonly ariaLabel: StringConstructor;
+                readonly modelValue: {
+                    readonly type: PropType<import('element-plus').CheckboxGroupValueType>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => never[];
+                };
+                readonly disabled: BooleanConstructor;
+                readonly min: NumberConstructor;
+                readonly max: NumberConstructor;
+                readonly size: {
+                    readonly type: PropType<"" | "small" | "default" | "large">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly fill: StringConstructor;
+                readonly textColor: StringConstructor;
+                readonly tag: {
+                    readonly type: PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "div";
+                };
+                readonly validateEvent: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+            }>> & {
+                "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxGroupValueType) => any) | undefined;
+                onChange?: ((val: import('element-plus').CheckboxValueType[]) => any) | undefined;
+            }, {}, {}, {}, {}, {
+                readonly disabled: boolean;
+                readonly modelValue: import('element-plus').CheckboxGroupValueType;
+                readonly validateEvent: boolean;
+                readonly tag: string;
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+            readonly ariaLabel: StringConstructor;
+            readonly modelValue: {
+                readonly type: PropType<import('element-plus').CheckboxGroupValueType>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => never[];
+            };
+            readonly disabled: BooleanConstructor;
+            readonly min: NumberConstructor;
+            readonly max: NumberConstructor;
+            readonly size: {
+                readonly type: PropType<"" | "small" | "default" | "large">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly fill: StringConstructor;
+            readonly textColor: StringConstructor;
+            readonly tag: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "div";
+            };
+            readonly validateEvent: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+        }>> & {
+            "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxGroupValueType) => any) | undefined;
+            onChange?: ((val: import('element-plus').CheckboxValueType[]) => any) | undefined;
+        }, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            "update:modelValue": (val: import('element-plus').CheckboxGroupValueType) => void;
+            change: (val: import('element-plus').CheckboxValueType[]) => void;
+        }, string, {
+            readonly disabled: boolean;
+            readonly modelValue: import('element-plus').CheckboxGroupValueType;
+            readonly validateEvent: boolean;
+            readonly tag: string;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) & import('vue').Plugin;
+        ElCheckbox: ({
+            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+                ariaControls: StringConstructor;
+                modelValue: {
+                    type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
+                    default: undefined;
+                };
+                label: {
+                    type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
+                    default: undefined;
+                };
+                value: {
+                    type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
+                    default: undefined;
+                };
+                indeterminate: BooleanConstructor;
+                disabled: BooleanConstructor;
+                checked: BooleanConstructor;
+                name: {
+                    type: StringConstructor;
+                    default: undefined;
+                };
+                trueValue: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                falseValue: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                trueLabel: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                falseLabel: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                id: {
+                    type: StringConstructor;
+                    default: undefined;
+                };
+                border: BooleanConstructor;
+                size: {
+                    readonly type: PropType<"" | "small" | "default" | "large">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                tabindex: (NumberConstructor | StringConstructor)[];
+                validateEvent: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & {
+                "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+            }, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                "update:modelValue": (val: import('element-plus').CheckboxValueType) => void;
+                change: (val: import('element-plus').CheckboxValueType) => void;
+            }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+                label: string | number | boolean | Record<string, any>;
+                disabled: boolean;
+                border: boolean;
+                value: string | number | boolean | Record<string, any>;
+                id: string;
+                name: string;
+                modelValue: string | number | boolean;
+                validateEvent: boolean;
+                indeterminate: boolean;
+                checked: boolean;
+                trueValue: string | number;
+                falseValue: string | number;
+                trueLabel: string | number;
+                falseLabel: string | number;
+            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import('vue').ExtractPropTypes<{
+                ariaControls: StringConstructor;
+                modelValue: {
+                    type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
+                    default: undefined;
+                };
+                label: {
+                    type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
+                    default: undefined;
+                };
+                value: {
+                    type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
+                    default: undefined;
+                };
+                indeterminate: BooleanConstructor;
+                disabled: BooleanConstructor;
+                checked: BooleanConstructor;
+                name: {
+                    type: StringConstructor;
+                    default: undefined;
+                };
+                trueValue: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                falseValue: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                trueLabel: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                falseLabel: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                id: {
+                    type: StringConstructor;
+                    default: undefined;
+                };
+                border: BooleanConstructor;
+                size: {
+                    readonly type: PropType<"" | "small" | "default" | "large">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                tabindex: (NumberConstructor | StringConstructor)[];
+                validateEvent: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & {
+                "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+            }, {}, {}, {}, {}, {
+                label: string | number | boolean | Record<string, any>;
+                disabled: boolean;
+                border: boolean;
+                value: string | number | boolean | Record<string, any>;
+                id: string;
+                name: string;
+                modelValue: string | number | boolean;
+                validateEvent: boolean;
+                indeterminate: boolean;
+                checked: boolean;
+                trueValue: string | number;
+                falseValue: string | number;
+                trueLabel: string | number;
+                falseLabel: string | number;
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+            ariaControls: StringConstructor;
+            modelValue: {
+                type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
+                default: undefined;
+            };
+            label: {
+                type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
+                default: undefined;
+            };
+            value: {
+                type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
+                default: undefined;
+            };
+            indeterminate: BooleanConstructor;
+            disabled: BooleanConstructor;
+            checked: BooleanConstructor;
+            name: {
+                type: StringConstructor;
+                default: undefined;
+            };
+            trueValue: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            falseValue: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            trueLabel: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            falseLabel: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            id: {
+                type: StringConstructor;
+                default: undefined;
+            };
+            border: BooleanConstructor;
+            size: {
+                readonly type: PropType<"" | "small" | "default" | "large">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            tabindex: (NumberConstructor | StringConstructor)[];
+            validateEvent: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & {
+            "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+            onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+        }, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            "update:modelValue": (val: import('element-plus').CheckboxValueType) => void;
+            change: (val: import('element-plus').CheckboxValueType) => void;
+        }, string, {
+            label: string | number | boolean | Record<string, any>;
+            disabled: boolean;
+            border: boolean;
+            value: string | number | boolean | Record<string, any>;
+            id: string;
+            name: string;
+            modelValue: string | number | boolean;
+            validateEvent: boolean;
+            indeterminate: boolean;
+            checked: boolean;
+            trueValue: string | number;
+            falseValue: string | number;
+            trueLabel: string | number;
+            falseLabel: string | number;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) & import('vue').Plugin) & {
+            CheckboxButton: {
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+                    ariaControls: StringConstructor;
+                    modelValue: {
+                        type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
+                        default: undefined;
+                    };
+                    label: {
+                        type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
+                        default: undefined;
+                    };
+                    value: {
+                        type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
+                        default: undefined;
+                    };
+                    indeterminate: BooleanConstructor;
+                    disabled: BooleanConstructor;
+                    checked: BooleanConstructor;
+                    name: {
+                        type: StringConstructor;
+                        default: undefined;
+                    };
+                    trueValue: {
+                        type: (NumberConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    falseValue: {
+                        type: (NumberConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    trueLabel: {
+                        type: (NumberConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    falseLabel: {
+                        type: (NumberConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    id: {
+                        type: StringConstructor;
+                        default: undefined;
+                    };
+                    border: BooleanConstructor;
+                    size: {
+                        readonly type: PropType<"" | "small" | "default" | "large">;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    tabindex: (NumberConstructor | StringConstructor)[];
+                    validateEvent: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & {
+                    "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                    onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                }, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    "update:modelValue": (val: import('element-plus').CheckboxValueType) => void;
+                    change: (val: import('element-plus').CheckboxValueType) => void;
+                }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+                    label: string | number | boolean | Record<string, any>;
+                    disabled: boolean;
+                    border: boolean;
+                    value: string | number | boolean | Record<string, any>;
+                    id: string;
+                    name: string;
+                    modelValue: string | number | boolean;
+                    validateEvent: boolean;
+                    indeterminate: boolean;
+                    checked: boolean;
+                    trueValue: string | number;
+                    falseValue: string | number;
+                    trueLabel: string | number;
+                    falseLabel: string | number;
+                }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('vue').ExtractPropTypes<{
+                    ariaControls: StringConstructor;
+                    modelValue: {
+                        type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
+                        default: undefined;
+                    };
+                    label: {
+                        type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
+                        default: undefined;
+                    };
+                    value: {
+                        type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
+                        default: undefined;
+                    };
+                    indeterminate: BooleanConstructor;
+                    disabled: BooleanConstructor;
+                    checked: BooleanConstructor;
+                    name: {
+                        type: StringConstructor;
+                        default: undefined;
+                    };
+                    trueValue: {
+                        type: (NumberConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    falseValue: {
+                        type: (NumberConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    trueLabel: {
+                        type: (NumberConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    falseLabel: {
+                        type: (NumberConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    id: {
+                        type: StringConstructor;
+                        default: undefined;
+                    };
+                    border: BooleanConstructor;
+                    size: {
+                        readonly type: PropType<"" | "small" | "default" | "large">;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    tabindex: (NumberConstructor | StringConstructor)[];
+                    validateEvent: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & {
+                    "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                    onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                }, {}, {}, {}, {}, {
+                    label: string | number | boolean | Record<string, any>;
+                    disabled: boolean;
+                    border: boolean;
+                    value: string | number | boolean | Record<string, any>;
+                    id: string;
+                    name: string;
+                    modelValue: string | number | boolean;
+                    validateEvent: boolean;
+                    indeterminate: boolean;
+                    checked: boolean;
+                    trueValue: string | number;
+                    falseValue: string | number;
+                    trueLabel: string | number;
+                    falseLabel: string | number;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                ariaControls: StringConstructor;
+                modelValue: {
+                    type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
+                    default: undefined;
+                };
+                label: {
+                    type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
+                    default: undefined;
+                };
+                value: {
+                    type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
+                    default: undefined;
+                };
+                indeterminate: BooleanConstructor;
+                disabled: BooleanConstructor;
+                checked: BooleanConstructor;
+                name: {
+                    type: StringConstructor;
+                    default: undefined;
+                };
+                trueValue: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                falseValue: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                trueLabel: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                falseLabel: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                id: {
+                    type: StringConstructor;
+                    default: undefined;
+                };
+                border: BooleanConstructor;
+                size: {
+                    readonly type: PropType<"" | "small" | "default" | "large">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                tabindex: (NumberConstructor | StringConstructor)[];
+                validateEvent: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & {
+                "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+            }, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                "update:modelValue": (val: import('element-plus').CheckboxValueType) => void;
+                change: (val: import('element-plus').CheckboxValueType) => void;
+            }, string, {
+                label: string | number | boolean | Record<string, any>;
+                disabled: boolean;
+                border: boolean;
+                value: string | number | boolean | Record<string, any>;
+                id: string;
+                name: string;
+                modelValue: string | number | boolean;
+                validateEvent: boolean;
+                indeterminate: boolean;
+                checked: boolean;
+                trueValue: string | number;
+                falseValue: string | number;
+                trueLabel: string | number;
+                falseLabel: string | number;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    default?(_: {}): any;
+                };
+            });
+            CheckboxGroup: {
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+                    readonly ariaLabel: StringConstructor;
+                    readonly modelValue: {
+                        readonly type: PropType<import('element-plus').CheckboxGroupValueType>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: () => never[];
+                    };
+                    readonly disabled: BooleanConstructor;
+                    readonly min: NumberConstructor;
+                    readonly max: NumberConstructor;
+                    readonly size: {
+                        readonly type: PropType<"" | "small" | "default" | "large">;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly fill: StringConstructor;
+                    readonly textColor: StringConstructor;
+                    readonly tag: {
+                        readonly type: PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "div";
+                    };
+                    readonly validateEvent: {
+                        readonly type: PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: true;
+                    };
+                }>> & {
+                    "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxGroupValueType) => any) | undefined;
+                    onChange?: ((val: import('element-plus').CheckboxValueType[]) => any) | undefined;
+                }, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    "update:modelValue": (val: import('element-plus').CheckboxGroupValueType) => void;
+                    change: (val: import('element-plus').CheckboxValueType[]) => void;
+                }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+                    readonly disabled: boolean;
+                    readonly modelValue: import('element-plus').CheckboxGroupValueType;
+                    readonly validateEvent: boolean;
+                    readonly tag: string;
+                }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('vue').ExtractPropTypes<{
+                    readonly ariaLabel: StringConstructor;
+                    readonly modelValue: {
+                        readonly type: PropType<import('element-plus').CheckboxGroupValueType>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: () => never[];
+                    };
+                    readonly disabled: BooleanConstructor;
+                    readonly min: NumberConstructor;
+                    readonly max: NumberConstructor;
+                    readonly size: {
+                        readonly type: PropType<"" | "small" | "default" | "large">;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly fill: StringConstructor;
+                    readonly textColor: StringConstructor;
+                    readonly tag: {
+                        readonly type: PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "div";
+                    };
+                    readonly validateEvent: {
+                        readonly type: PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: true;
+                    };
+                }>> & {
+                    "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxGroupValueType) => any) | undefined;
+                    onChange?: ((val: import('element-plus').CheckboxValueType[]) => any) | undefined;
+                }, {}, {}, {}, {}, {
+                    readonly disabled: boolean;
+                    readonly modelValue: import('element-plus').CheckboxGroupValueType;
+                    readonly validateEvent: boolean;
+                    readonly tag: string;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                readonly ariaLabel: StringConstructor;
+                readonly modelValue: {
+                    readonly type: PropType<import('element-plus').CheckboxGroupValueType>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => never[];
+                };
+                readonly disabled: BooleanConstructor;
+                readonly min: NumberConstructor;
+                readonly max: NumberConstructor;
+                readonly size: {
+                    readonly type: PropType<"" | "small" | "default" | "large">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly fill: StringConstructor;
+                readonly textColor: StringConstructor;
+                readonly tag: {
+                    readonly type: PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "div";
+                };
+                readonly validateEvent: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+            }>> & {
+                "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxGroupValueType) => any) | undefined;
+                onChange?: ((val: import('element-plus').CheckboxValueType[]) => any) | undefined;
+            }, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                "update:modelValue": (val: import('element-plus').CheckboxGroupValueType) => void;
+                change: (val: import('element-plus').CheckboxValueType[]) => void;
+            }, string, {
+                readonly disabled: boolean;
+                readonly modelValue: import('element-plus').CheckboxGroupValueType;
+                readonly validateEvent: boolean;
+                readonly tag: string;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    default?(_: {}): any;
+                };
+            });
+        };
+        EleTooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            bodyStyle: PropType<import('../../ele-app/types').StyleValue>;
+            bg: StringConstructor;
+            arrowBg: StringConstructor;
+            width: (NumberConstructor | StringConstructor)[];
+            isPopover: BooleanConstructor;
+            showAfter: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            hideAfter: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 200;
+            };
+            autoClose: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            effect: {
+                readonly type: PropType<import('element-plus').PopperEffect>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "dark";
+            };
+            ariaLabel: StringConstructor;
+            placement: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "bottom";
+            };
+            teleported: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            appendTo: {
+                readonly type: PropType<string | HTMLElement>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            disabled: BooleanConstructor;
+            offset: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 12;
+            };
+            persistent: BooleanConstructor;
+            zIndex: NumberConstructor;
+            visible: {
+                readonly type: PropType<boolean | null>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: null;
+            };
+            trigger: {
+                readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "hover";
+            };
+            triggerKeys: {
+                readonly type: PropType<string[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => string[];
+            };
+            popperOptions: {
+                readonly type: PropType<any>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => {};
+            };
+            transition: StringConstructor;
+            content: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            enterable: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            showArrow: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: boolean;
+            };
+            arrowOffset: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 5;
+            };
+            virtualRef: {
+                readonly type: PropType<import('element-plus').Measurable>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            virtualTriggering: BooleanConstructor;
+            rawContent: BooleanConstructor;
+            gpuAcceleration: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            className: StringConstructor;
+            popperClass: StringConstructor;
+            popperStyle: PropType<import('../../ele-app/types').StyleValue>;
+        }>, {
+            tooltipRef: import('vue').Ref<import('../../ele-app/el').ElTooltipInstance | undefined, import('../../ele-app/el').ElTooltipInstance | undefined>;
+            rootProps: import('vue').ComputedRef<Partial<import('element-plus').ElTooltipProps>>;
+            popperRef: import('vue').ComputedRef<import('../../ele-app/el').ElPopperInstance>;
+            contentRef: import('vue').ComputedRef<import('element-plus').TooltipContentInstance | undefined>;
+            isFocusInsideContent: () => void;
+            updatePopper: () => void;
+            handleOpen: (opt?: Event) => void;
+            handleClose: (opt?: Event) => void;
+            hide: (opt?: Event) => void;
+            handleUpdateVisible: (visible: boolean) => void;
+            handlePopBeforeShow: (e: Event) => void;
+            handlePopBeforeHide: (e: Event) => void;
+            handlePopShow: (e: Event) => void;
+            handlePopHide: (e: Event) => void;
+            handlePopOpen: (e: any) => void;
+            handlePopClose: (e: any) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, import('../../ele-tooltip/props').TooltipEmits, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            bodyStyle: PropType<import('../../ele-app/types').StyleValue>;
+            bg: StringConstructor;
+            arrowBg: StringConstructor;
+            width: (NumberConstructor | StringConstructor)[];
+            isPopover: BooleanConstructor;
+            showAfter: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            hideAfter: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 200;
+            };
+            autoClose: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            effect: {
+                readonly type: PropType<import('element-plus').PopperEffect>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "dark";
+            };
+            ariaLabel: StringConstructor;
+            placement: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "bottom";
+            };
+            teleported: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            appendTo: {
+                readonly type: PropType<string | HTMLElement>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            disabled: BooleanConstructor;
+            offset: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 12;
+            };
+            persistent: BooleanConstructor;
+            zIndex: NumberConstructor;
+            visible: {
+                readonly type: PropType<boolean | null>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: null;
+            };
+            trigger: {
+                readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "hover";
+            };
+            triggerKeys: {
+                readonly type: PropType<string[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => string[];
+            };
+            popperOptions: {
+                readonly type: PropType<any>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => {};
+            };
+            transition: StringConstructor;
+            content: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            enterable: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            showArrow: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: boolean;
+            };
+            arrowOffset: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 5;
+            };
+            virtualRef: {
+                readonly type: PropType<import('element-plus').Measurable>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            virtualTriggering: BooleanConstructor;
+            rawContent: BooleanConstructor;
+            gpuAcceleration: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            className: StringConstructor;
+            popperClass: StringConstructor;
+            popperStyle: PropType<import('../../ele-app/types').StyleValue>;
+        }>> & Readonly<{
+            onClose?: ((e: any) => any) | undefined;
+            onHide?: ((e: Event) => any) | undefined;
+            onOpen?: ((e: any) => any) | undefined;
+            "onUpdate:visible"?: ((visible: boolean) => any) | undefined;
+            "onBefore-show"?: ((e: Event) => any) | undefined;
+            "onBefore-hide"?: ((e: Event) => any) | undefined;
+            onShow?: ((e: Event) => any) | undefined;
+        }>, {
+            showAfter: number;
+            hideAfter: number;
+            autoClose: number;
+            effect: import('element-plus').PopperEffect;
+            placement: string;
+            teleported: boolean;
+            disabled: boolean;
+            offset: number;
+            persistent: boolean;
+            visible: boolean | null;
+            trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
+            triggerKeys: string[];
+            popperOptions: any;
+            content: string;
+            enterable: boolean;
+            showArrow: boolean;
+            arrowOffset: number;
+            virtualTriggering: boolean;
+            rawContent: boolean;
+            gpuAcceleration: boolean;
+            isPopover: boolean;
+        }, {}, {
+            ElTooltip: {
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+                    showArrow: {
+                        readonly type: PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: boolean;
+                    };
+                    arrowOffset: {
+                        readonly type: PropType<number>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: 5;
+                    };
+                    disabled: BooleanConstructor;
+                    trigger: {
+                        readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "hover";
+                    };
+                    triggerKeys: {
+                        readonly type: PropType<string[]>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: () => string[];
+                    };
+                    virtualRef: {
+                        readonly type: PropType<import('element-plus').Measurable>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    virtualTriggering: BooleanConstructor;
+                    onMouseenter: {
+                        readonly type: PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    onMouseleave: {
+                        readonly type: PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    onClick: {
+                        readonly type: PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    onKeydown: {
+                        readonly type: PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    onFocus: {
+                        readonly type: PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    onBlur: {
+                        readonly type: PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    onContextmenu: {
+                        readonly type: PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    id: StringConstructor;
+                    open: BooleanConstructor;
+                    ariaLabel: StringConstructor;
+                    appendTo: {
+                        readonly type: PropType<string | HTMLElement>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    content: {
+                        readonly type: PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "";
+                    };
+                    rawContent: BooleanConstructor;
+                    persistent: BooleanConstructor;
+                    visible: {
+                        readonly type: PropType<boolean | null>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: null;
+                    };
+                    transition: StringConstructor;
+                    teleported: {
+                        readonly type: PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: true;
+                    };
+                    style: {
+                        readonly type: PropType<import('vue').StyleValue>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    className: {
+                        readonly type: PropType<string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | any[] | {
+                            [x: string]: boolean;
+                        })[])[])[])[])[])[])[])[])[])[]>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    effect: {
+                        readonly type: PropType<import('element-plus').PopperEffect>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "dark";
+                    };
+                    enterable: {
+                        readonly type: PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: true;
+                    };
+                    pure: BooleanConstructor;
+                    focusOnShow: {
+                        readonly type: PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: false;
+                    };
+                    trapping: {
+                        readonly type: PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: false;
+                    };
+                    popperClass: {
+                        readonly type: PropType<string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | any[] | {
+                            [x: string]: boolean;
+                        })[])[])[])[])[])[])[])[])[])[]>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    popperStyle: {
+                        readonly type: PropType<import('vue').StyleValue>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    referenceEl: {
+                        readonly type: PropType<HTMLElement>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    triggerTargetEl: {
+                        readonly type: PropType<HTMLElement>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    stopPopperMouseEvent: {
+                        readonly type: PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: true;
+                    };
+                    zIndex: NumberConstructor;
+                    boundariesPadding: {
+                        readonly type: PropType<number>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: 0;
+                    };
+                    fallbackPlacements: {
+                        readonly type: PropType<Placement[]>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: undefined;
+                    };
+                    gpuAcceleration: {
+                        readonly type: PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: true;
+                    };
+                    offset: {
+                        readonly type: PropType<number>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: 12;
+                    };
+                    placement: {
+                        readonly type: PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "bottom";
+                    };
+                    popperOptions: {
+                        readonly type: PropType<any>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: () => {};
+                    };
+                    strategy: {
+                        readonly type: PropType<"fixed" | "absolute">;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "absolute";
+                    };
+                    showAfter: {
+                        readonly type: PropType<number>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: 0;
+                    };
+                    hideAfter: {
+                        readonly type: PropType<number>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: 200;
+                    };
+                    autoClose: {
+                        readonly type: PropType<number>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: 0;
+                    };
+                    "onUpdate:visible": {
+                        readonly type: PropType<(val: boolean) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    role: {
+                        readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "tooltip";
+                    };
+                }>>, {
+                    popperRef: import('vue').Ref<import('element-plus').PopperInstance | undefined>;
+                    contentRef: import('vue').Ref<import('element-plus').TooltipContentInstance | undefined>;
+                    isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+                    updatePopper: () => void;
+                    onOpen: (event?: Event) => void;
+                    onClose: (event?: Event) => void;
+                    hide: (event?: Event) => void;
+                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    [x: string]: (...args: any[]) => void;
+                }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+                    disabled: boolean;
+                    content: string;
+                    offset: number;
+                    visible: boolean | null;
+                    open: boolean;
+                    placement: string;
+                    strategy: "fixed" | "absolute";
+                    effect: import('element-plus').PopperEffect;
+                    showAfter: number;
+                    hideAfter: number;
+                    autoClose: number;
+                    trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
+                    role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
+                    virtualTriggering: boolean;
+                    arrowOffset: number;
+                    boundariesPadding: number;
+                    fallbackPlacements: Placement[];
+                    gpuAcceleration: boolean;
+                    popperOptions: Partial<Options>;
+                    enterable: boolean;
+                    focusOnShow: boolean;
+                    trapping: boolean;
+                    stopPopperMouseEvent: boolean;
+                    pure: boolean;
+                    triggerKeys: string[];
+                    teleported: boolean;
+                    rawContent: boolean;
+                    persistent: boolean;
+                    showArrow: boolean;
+                }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('vue').ExtractPropTypes<{
+                    showArrow: {
+                        readonly type: PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: boolean;
+                    };
+                    arrowOffset: {
+                        readonly type: PropType<number>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: 5;
+                    };
+                    disabled: BooleanConstructor;
+                    trigger: {
+                        readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "hover";
+                    };
+                    triggerKeys: {
+                        readonly type: PropType<string[]>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: () => string[];
+                    };
+                    virtualRef: {
+                        readonly type: PropType<import('element-plus').Measurable>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    virtualTriggering: BooleanConstructor;
+                    onMouseenter: {
+                        readonly type: PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    onMouseleave: {
+                        readonly type: PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    onClick: {
+                        readonly type: PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    onKeydown: {
+                        readonly type: PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    onFocus: {
+                        readonly type: PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    onBlur: {
+                        readonly type: PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    onContextmenu: {
+                        readonly type: PropType<(e: Event) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    id: StringConstructor;
+                    open: BooleanConstructor;
+                    ariaLabel: StringConstructor;
+                    appendTo: {
+                        readonly type: PropType<string | HTMLElement>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    content: {
+                        readonly type: PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "";
+                    };
+                    rawContent: BooleanConstructor;
+                    persistent: BooleanConstructor;
+                    visible: {
+                        readonly type: PropType<boolean | null>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: null;
+                    };
+                    transition: StringConstructor;
+                    teleported: {
+                        readonly type: PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: true;
+                    };
+                    style: {
+                        readonly type: PropType<import('vue').StyleValue>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    className: {
+                        readonly type: PropType<string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | any[] | {
+                            [x: string]: boolean;
+                        })[])[])[])[])[])[])[])[])[])[]>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    effect: {
+                        readonly type: PropType<import('element-plus').PopperEffect>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "dark";
+                    };
+                    enterable: {
+                        readonly type: PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: true;
+                    };
+                    pure: BooleanConstructor;
+                    focusOnShow: {
+                        readonly type: PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: false;
+                    };
+                    trapping: {
+                        readonly type: PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: false;
+                    };
+                    popperClass: {
+                        readonly type: PropType<string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | {
+                            [x: string]: boolean;
+                        } | (string | any[] | {
+                            [x: string]: boolean;
+                        })[])[])[])[])[])[])[])[])[])[]>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    popperStyle: {
+                        readonly type: PropType<import('vue').StyleValue>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    referenceEl: {
+                        readonly type: PropType<HTMLElement>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    triggerTargetEl: {
+                        readonly type: PropType<HTMLElement>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    stopPopperMouseEvent: {
+                        readonly type: PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: true;
+                    };
+                    zIndex: NumberConstructor;
+                    boundariesPadding: {
+                        readonly type: PropType<number>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: 0;
+                    };
+                    fallbackPlacements: {
+                        readonly type: PropType<Placement[]>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: undefined;
+                    };
+                    gpuAcceleration: {
+                        readonly type: PropType<boolean>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: true;
+                    };
+                    offset: {
+                        readonly type: PropType<number>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: 12;
+                    };
+                    placement: {
+                        readonly type: PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "bottom";
+                    };
+                    popperOptions: {
+                        readonly type: PropType<any>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: () => {};
+                    };
+                    strategy: {
+                        readonly type: PropType<"fixed" | "absolute">;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "absolute";
+                    };
+                    showAfter: {
+                        readonly type: PropType<number>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: 0;
+                    };
+                    hideAfter: {
+                        readonly type: PropType<number>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: 200;
+                    };
+                    autoClose: {
+                        readonly type: PropType<number>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: 0;
+                    };
+                    "onUpdate:visible": {
+                        readonly type: PropType<(val: boolean) => void>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    role: {
+                        readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    } & {
+                        readonly default: "tooltip";
+                    };
+                }>>, {
+                    popperRef: import('vue').Ref<import('element-plus').PopperInstance | undefined>;
+                    contentRef: import('vue').Ref<import('element-plus').TooltipContentInstance | undefined>;
+                    isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+                    updatePopper: () => void;
+                    onOpen: (event?: Event) => void;
+                    onClose: (event?: Event) => void;
+                    hide: (event?: Event) => void;
+                }, {}, {}, {}, {
+                    disabled: boolean;
+                    content: string;
+                    offset: number;
+                    visible: boolean | null;
+                    open: boolean;
+                    placement: string;
+                    strategy: "fixed" | "absolute";
+                    effect: import('element-plus').PopperEffect;
+                    showAfter: number;
+                    hideAfter: number;
+                    autoClose: number;
+                    trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
+                    role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
+                    virtualTriggering: boolean;
+                    arrowOffset: number;
+                    boundariesPadding: number;
+                    fallbackPlacements: Placement[];
+                    gpuAcceleration: boolean;
+                    popperOptions: Partial<Options>;
+                    enterable: boolean;
+                    focusOnShow: boolean;
+                    trapping: boolean;
+                    stopPopperMouseEvent: boolean;
+                    pure: boolean;
+                    triggerKeys: string[];
+                    teleported: boolean;
+                    rawContent: boolean;
+                    persistent: boolean;
+                    showArrow: boolean;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                showArrow: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: boolean;
+                };
+                arrowOffset: {
+                    readonly type: PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 5;
+                };
+                disabled: BooleanConstructor;
+                trigger: {
+                    readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "hover";
+                };
+                triggerKeys: {
+                    readonly type: PropType<string[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => string[];
+                };
+                virtualRef: {
+                    readonly type: PropType<import('element-plus').Measurable>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                virtualTriggering: BooleanConstructor;
+                onMouseenter: {
+                    readonly type: PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onMouseleave: {
+                    readonly type: PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onClick: {
+                    readonly type: PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onKeydown: {
+                    readonly type: PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onFocus: {
+                    readonly type: PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onBlur: {
+                    readonly type: PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onContextmenu: {
+                    readonly type: PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                id: StringConstructor;
+                open: BooleanConstructor;
+                ariaLabel: StringConstructor;
+                appendTo: {
+                    readonly type: PropType<string | HTMLElement>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                content: {
+                    readonly type: PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                rawContent: BooleanConstructor;
+                persistent: BooleanConstructor;
+                visible: {
+                    readonly type: PropType<boolean | null>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: null;
+                };
+                transition: StringConstructor;
+                teleported: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                style: {
+                    readonly type: PropType<import('vue').StyleValue>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                className: {
+                    readonly type: PropType<string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | any[] | {
+                        [x: string]: boolean;
+                    })[])[])[])[])[])[])[])[])[])[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                effect: {
+                    readonly type: PropType<import('element-plus').PopperEffect>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "dark";
+                };
+                enterable: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                pure: BooleanConstructor;
+                focusOnShow: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: false;
+                };
+                trapping: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: false;
+                };
+                popperClass: {
+                    readonly type: PropType<string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | any[] | {
+                        [x: string]: boolean;
+                    })[])[])[])[])[])[])[])[])[])[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                popperStyle: {
+                    readonly type: PropType<import('vue').StyleValue>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                referenceEl: {
+                    readonly type: PropType<HTMLElement>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                triggerTargetEl: {
+                    readonly type: PropType<HTMLElement>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                stopPopperMouseEvent: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                zIndex: NumberConstructor;
+                boundariesPadding: {
+                    readonly type: PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                fallbackPlacements: {
+                    readonly type: PropType<Placement[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: undefined;
+                };
+                gpuAcceleration: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                offset: {
+                    readonly type: PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 12;
+                };
+                placement: {
+                    readonly type: PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "bottom";
+                };
+                popperOptions: {
+                    readonly type: PropType<any>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => {};
+                };
+                strategy: {
+                    readonly type: PropType<"fixed" | "absolute">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "absolute";
+                };
+                showAfter: {
+                    readonly type: PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                hideAfter: {
+                    readonly type: PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 200;
+                };
+                autoClose: {
+                    readonly type: PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                "onUpdate:visible": {
+                    readonly type: PropType<(val: boolean) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                role: {
+                    readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "tooltip";
+                };
+            }>>, {
+                popperRef: import('vue').Ref<import('element-plus').PopperInstance | undefined>;
+                contentRef: import('vue').Ref<import('element-plus').TooltipContentInstance | undefined>;
+                isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+                updatePopper: () => void;
+                onOpen: (event?: Event) => void;
+                onClose: (event?: Event) => void;
+                hide: (event?: Event) => void;
+            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                [x: string]: (...args: any[]) => void;
+            }, string, {
+                disabled: boolean;
+                content: string;
+                offset: number;
+                visible: boolean | null;
+                open: boolean;
+                placement: string;
+                strategy: "fixed" | "absolute";
+                effect: import('element-plus').PopperEffect;
+                showAfter: number;
+                hideAfter: number;
+                autoClose: number;
+                trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
+                role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
+                virtualTriggering: boolean;
+                arrowOffset: number;
+                boundariesPadding: number;
+                fallbackPlacements: Placement[];
+                gpuAcceleration: boolean;
+                popperOptions: Partial<Options>;
+                enterable: boolean;
+                focusOnShow: boolean;
+                trapping: boolean;
+                stopPopperMouseEvent: boolean;
+                pure: boolean;
+                triggerKeys: string[];
+                teleported: boolean;
+                rawContent: boolean;
+                persistent: boolean;
+                showArrow: boolean;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    default?(_: {}): any;
+                    content?(_: {}): any;
+                };
+            }) & import('vue').Plugin;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        FilterFilled: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    CellRender: typeof CellRender;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;