import { PropType } from 'vue';
import { Column, Filter, TableSize, HeaderCellClass, HeaderCellStyle } from '../../ele-data-table/types';
import { VirtualColumn, HeaderColumns, SortBy, CellFilterChangeParams, ColSize } from '../types';

declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
    /** 表头行配置 */
    headerCols: PropType<HeaderColumns>;
    /** 表头所有行列宽 */
    headerColSizes: PropType<ColSize[]>;
    /** 当前行索引 */
    headerIndex: NumberConstructor;
    /** 表格排序状态 */
    sortBy: PropType<SortBy>;
    /** 表格筛选值 */
    filtered: PropType<Filter>;
    /** 表格是否是全选状态 */
    isCheckAll: BooleanConstructor;
    /** 表格是否是半选状态 */
    isIndeterminate: BooleanConstructor;
    /** 是否禁用表头选择框 */
    disabledCheckbox: BooleanConstructor;
    /** 表格尺寸 */
    tableSize: PropType<TableSize>;
    /** 表头单元格类名自定义 */
    headerCellClass: PropType<HeaderCellClass>;
    /** 表头单元样式自定义 */
    headerCellStyle: PropType<HeaderCellStyle>;
    /** 表头单元格是否溢出省略 */
    headerEllipsis: BooleanConstructor;
    /** 表格行高 */
    rowHeight: NumberConstructor;
}>, {
    getKey: (column: VirtualColumn, columnIndex: number) => string;
    getFiltered: (column: VirtualColumn) => import('../../ele-data-table/types').FilterValue;
    handleCellCheckedChange: (checked: boolean) => void;
    handleCellFilterChange: (params: CellFilterChangeParams) => void;
    handleCellClick: (col: Column, e: MouseEvent) => void;
    handleCellContextmenu: (col: Column, e: MouseEvent) => void;
    handleCellMouseenter: (col: Column, e: MouseEvent) => void;
}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
    /** 多选框选中改变事件 */
    checkedChange: (_checked: boolean) => true;
    /** 列筛选改变事件 */
    filterChange: (_params: CellFilterChangeParams) => true;
    /** 单元格点击事件 */
    cellClick: (_col: Column, _e: MouseEvent) => true;
    /** 单元格右键事件 */
    cellContextmenu: (_col: Column, _e: MouseEvent) => true;
    /** 单元格鼠标移入事件 */
    cellMouseenter: (_col: Column, _e: MouseEvent) => true;
}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
    /** 表头行配置 */
    headerCols: PropType<HeaderColumns>;
    /** 表头所有行列宽 */
    headerColSizes: PropType<ColSize[]>;
    /** 当前行索引 */
    headerIndex: NumberConstructor;
    /** 表格排序状态 */
    sortBy: PropType<SortBy>;
    /** 表格筛选值 */
    filtered: PropType<Filter>;
    /** 表格是否是全选状态 */
    isCheckAll: BooleanConstructor;
    /** 表格是否是半选状态 */
    isIndeterminate: BooleanConstructor;
    /** 是否禁用表头选择框 */
    disabledCheckbox: BooleanConstructor;
    /** 表格尺寸 */
    tableSize: PropType<TableSize>;
    /** 表头单元格类名自定义 */
    headerCellClass: PropType<HeaderCellClass>;
    /** 表头单元样式自定义 */
    headerCellStyle: PropType<HeaderCellStyle>;
    /** 表头单元格是否溢出省略 */
    headerEllipsis: BooleanConstructor;
    /** 表格行高 */
    rowHeight: NumberConstructor;
}>> & Readonly<{
    onFilterChange?: ((_params: CellFilterChangeParams) => any) | undefined;
    onCellClick?: ((_col: Column, _e: MouseEvent) => any) | undefined;
    onCellContextmenu?: ((_col: Column, _e: MouseEvent) => any) | undefined;
    onCheckedChange?: ((_checked: boolean) => any) | undefined;
    onCellMouseenter?: ((_col: Column, _e: MouseEvent) => any) | undefined;
}>, {
    headerEllipsis: boolean;
    isCheckAll: boolean;
    isIndeterminate: boolean;
    disabledCheckbox: boolean;
}, {}, {
    HeaderCell: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        column: PropType<import('../types').HeaderColumn>;
        columnIndex: NumberConstructor;
        headerIndex: NumberConstructor;
        colSize: PropType<ColSize>;
        sortBy: PropType<SortBy>;
        filterValue: PropType<import('../../ele-data-table/types').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<import('../../ele-app/types').StyleValues | undefined>;
        cellTitle: import('vue').ComputedRef<string | undefined>;
        renderOpt: import('vue').ComputedRef<import('../types').CustomRenderProps>;
        handleCheckedChange: (checked: boolean) => void;
        handleFilterChange: (value: import('../../ele-data-table/types').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<import('../types').HeaderColumn>;
        columnIndex: NumberConstructor;
        headerIndex: NumberConstructor;
        colSize: PropType<ColSize>;
        sortBy: PropType<SortBy>;
        filterValue: PropType<import('../../ele-data-table/types').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: import('element-plus/es/utils/index').SFCWithInstall<{
                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: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
                        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>;
                    border: boolean;
                    disabled: 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: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
                        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>;
                    border: boolean;
                    disabled: 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: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
                    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>;
                border: boolean;
                disabled: 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;
                };
            })> & {
                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: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
                            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>;
                        border: boolean;
                        disabled: 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: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
                            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>;
                        border: boolean;
                        disabled: 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: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
                        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>;
                    border: boolean;
                    disabled: 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: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').CheckboxGroupValueType) | (() => import('element-plus').CheckboxGroupValueType) | ((new (...args: any[]) => import('element-plus').CheckboxGroupValueType) | (() => import('element-plus').CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;
                        readonly disabled: BooleanConstructor;
                        readonly min: NumberConstructor;
                        readonly max: NumberConstructor;
                        readonly size: {
                            readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly fill: StringConstructor;
                        readonly textColor: StringConstructor;
                        readonly tag: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
                        readonly validateEvent: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    }>> & {
                        "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: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                        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: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').CheckboxGroupValueType) | (() => import('element-plus').CheckboxGroupValueType) | ((new (...args: any[]) => import('element-plus').CheckboxGroupValueType) | (() => import('element-plus').CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;
                        readonly disabled: BooleanConstructor;
                        readonly min: NumberConstructor;
                        readonly max: NumberConstructor;
                        readonly size: {
                            readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly fill: StringConstructor;
                        readonly textColor: StringConstructor;
                        readonly tag: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
                        readonly validateEvent: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    }>> & {
                        "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: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                        readonly tag: string;
                    }>;
                    __isFragment?: never;
                    __isTeleport?: never;
                    __isSuspense?: never;
                } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                    readonly ariaLabel: StringConstructor;
                    readonly modelValue: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').CheckboxGroupValueType) | (() => import('element-plus').CheckboxGroupValueType) | ((new (...args: any[]) => import('element-plus').CheckboxGroupValueType) | (() => import('element-plus').CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;
                    readonly disabled: BooleanConstructor;
                    readonly min: NumberConstructor;
                    readonly max: NumberConstructor;
                    readonly size: {
                        readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly fill: StringConstructor;
                    readonly textColor: StringConstructor;
                    readonly tag: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
                    readonly validateEvent: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                }>> & {
                    "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: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    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<import('../../ele-data-table/types').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: import('../../ele-data-table/types').FilterValue) => void;
            handleConfirm: () => void;
            handleReset: () => void;
            handleBeforeEnter: () => void;
        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
            change: (_filtered: import('../../ele-data-table/types').FilterValue) => true;
        }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
            filtered: PropType<import('../../ele-data-table/types').FilterValue>;
            filterMultiple: BooleanConstructor;
            filters: PropType<Column["filters"]>;
            filterPlacement: {
                type: PropType<import('../../ele-app/plus').EleTooltipProps["placement"]>;
                default: string;
            };
        }>> & Readonly<{
            onChange?: ((_filtered: import('../../ele-data-table/types').FilterValue) => any) | undefined;
        }>, {
            filterPlacement: string | undefined;
            filterMultiple: boolean;
        }, {}, {
            ElIcon: import('element-plus/es/utils/index').SFCWithInstall<{
                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                    readonly size: {
                        readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly color: {
                        readonly type: import('vue/dist/vue.js').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: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly color: {
                        readonly type: import('vue/dist/vue.js').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: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly color: {
                    readonly type: import('vue/dist/vue.js').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;
                };
            })>;
            ElButton: import('element-plus/es/utils/index').SFCWithInstall<{
                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                    readonly size: {
                        readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly disabled: BooleanConstructor;
                    readonly type: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "" | "text" | "default" | "success" | "warning" | "info" | "primary" | "danger", unknown, "", boolean>;
                    readonly icon: {
                        readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) | ((new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>))[], unknown, unknown>>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly nativeType: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "button" | "reset" | "submit", unknown, "button", boolean>;
                    readonly loading: BooleanConstructor;
                    readonly loadingIcon: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) | ((new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>))[], unknown, unknown, () => any, boolean>;
                    readonly plain: BooleanConstructor;
                    readonly text: BooleanConstructor;
                    readonly link: BooleanConstructor;
                    readonly bg: BooleanConstructor;
                    readonly autofocus: BooleanConstructor;
                    readonly round: BooleanConstructor;
                    readonly circle: BooleanConstructor;
                    readonly color: StringConstructor;
                    readonly dark: BooleanConstructor;
                    readonly autoInsertSpace: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
                    readonly tag: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) | ((new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>))[], unknown, unknown, "button", boolean>;
                }>> & {
                    onClick?: ((evt: MouseEvent) => any) | undefined;
                }, {
                    ref: import('vue').Ref<HTMLButtonElement | undefined>;
                    size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
                    type: import('vue').ComputedRef<"text" | "" | "default" | "success" | "warning" | "info" | "primary" | "danger">;
                    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 round: boolean;
                    readonly dark: boolean;
                    readonly disabled: boolean;
                    readonly type: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "text" | "default" | "success" | "warning" | "info" | "primary" | "danger", unknown>;
                    readonly bg: boolean;
                    readonly loading: boolean;
                    readonly autofocus: boolean;
                    readonly tag: import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) | ((new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>))[], unknown, unknown>;
                    readonly nativeType: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "button" | "reset" | "submit", unknown>;
                    readonly loadingIcon: import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) | ((new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>))[], unknown, unknown>;
                    readonly autoInsertSpace: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    readonly plain: 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: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly disabled: BooleanConstructor;
                    readonly type: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "" | "text" | "default" | "success" | "warning" | "info" | "primary" | "danger", unknown, "", boolean>;
                    readonly icon: {
                        readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) | ((new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>))[], unknown, unknown>>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly nativeType: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "button" | "reset" | "submit", unknown, "button", boolean>;
                    readonly loading: BooleanConstructor;
                    readonly loadingIcon: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) | ((new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>))[], unknown, unknown, () => any, boolean>;
                    readonly plain: BooleanConstructor;
                    readonly text: BooleanConstructor;
                    readonly link: BooleanConstructor;
                    readonly bg: BooleanConstructor;
                    readonly autofocus: BooleanConstructor;
                    readonly round: BooleanConstructor;
                    readonly circle: BooleanConstructor;
                    readonly color: StringConstructor;
                    readonly dark: BooleanConstructor;
                    readonly autoInsertSpace: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
                    readonly tag: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) | ((new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>))[], unknown, unknown, "button", boolean>;
                }>> & {
                    onClick?: ((evt: MouseEvent) => any) | undefined;
                }, {
                    ref: import('vue').Ref<HTMLButtonElement | undefined>;
                    size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
                    type: import('vue').ComputedRef<"text" | "" | "default" | "success" | "warning" | "info" | "primary" | "danger">;
                    disabled: import('vue').ComputedRef<boolean>;
                    shouldAddSpace: import('vue').ComputedRef<boolean>;
                }, {}, {}, {}, {
                    readonly link: boolean;
                    readonly circle: boolean;
                    readonly text: boolean;
                    readonly round: boolean;
                    readonly dark: boolean;
                    readonly disabled: boolean;
                    readonly type: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "text" | "default" | "success" | "warning" | "info" | "primary" | "danger", unknown>;
                    readonly bg: boolean;
                    readonly loading: boolean;
                    readonly autofocus: boolean;
                    readonly tag: import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) | ((new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>))[], unknown, unknown>;
                    readonly nativeType: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "button" | "reset" | "submit", unknown>;
                    readonly loadingIcon: import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) | ((new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>))[], unknown, unknown>;
                    readonly autoInsertSpace: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    readonly plain: boolean;
                }>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                readonly size: {
                    readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly disabled: BooleanConstructor;
                readonly type: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "" | "text" | "default" | "success" | "warning" | "info" | "primary" | "danger", unknown, "", boolean>;
                readonly icon: {
                    readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) | ((new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>))[], unknown, unknown>>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly nativeType: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "button" | "reset" | "submit", unknown, "button", boolean>;
                readonly loading: BooleanConstructor;
                readonly loadingIcon: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) | ((new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>))[], unknown, unknown, () => any, boolean>;
                readonly plain: BooleanConstructor;
                readonly text: BooleanConstructor;
                readonly link: BooleanConstructor;
                readonly bg: BooleanConstructor;
                readonly autofocus: BooleanConstructor;
                readonly round: BooleanConstructor;
                readonly circle: BooleanConstructor;
                readonly color: StringConstructor;
                readonly dark: BooleanConstructor;
                readonly autoInsertSpace: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
                readonly tag: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) | ((new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>))[], unknown, unknown, "button", boolean>;
            }>> & {
                onClick?: ((evt: MouseEvent) => any) | undefined;
            }, {
                ref: import('vue').Ref<HTMLButtonElement | undefined>;
                size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
                type: import('vue').ComputedRef<"text" | "" | "default" | "success" | "warning" | "info" | "primary" | "danger">;
                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 round: boolean;
                readonly dark: boolean;
                readonly disabled: boolean;
                readonly type: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "text" | "default" | "success" | "warning" | "info" | "primary" | "danger", unknown>;
                readonly bg: boolean;
                readonly loading: boolean;
                readonly autofocus: boolean;
                readonly tag: import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) | ((new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>))[], unknown, unknown>;
                readonly nativeType: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "button" | "reset" | "submit", unknown>;
                readonly loadingIcon: import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) | ((new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>))[], unknown, unknown>;
                readonly autoInsertSpace: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                readonly plain: 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;
                };
            })> & {
                ButtonGroup: {
                    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                        readonly size: {
                            readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly type: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "" | "text" | "default" | "success" | "warning" | "info" | "primary" | "danger", unknown, "", boolean>;
                    }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                        readonly type: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "text" | "default" | "success" | "warning" | "info" | "primary" | "danger", unknown>;
                    }, 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: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly type: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "" | "text" | "default" | "success" | "warning" | "info" | "primary" | "danger", unknown, "", boolean>;
                    }>>, {}, {}, {}, {}, {
                        readonly type: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "text" | "default" | "success" | "warning" | "info" | "primary" | "danger", unknown>;
                    }>;
                    __isFragment?: never;
                    __isTeleport?: never;
                    __isSuspense?: never;
                } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                    readonly size: {
                        readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly type: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "" | "text" | "default" | "success" | "warning" | "info" | "primary" | "danger", unknown, "", boolean>;
                }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
                    readonly type: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "text" | "default" | "success" | "warning" | "info" | "primary" | "danger", unknown>;
                }, {}, 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: import('element-plus/es/utils/index').SFCWithInstall<{
                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                    readonly ariaLabel: StringConstructor;
                    readonly ariaOrientation: {
                        readonly type: import('vue/dist/vue.js').PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly height: import('element-plus/es/utils/index').EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
                    readonly maxHeight: import('element-plus/es/utils/index').EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
                    readonly native: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                    readonly wrapStyle: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('vue').StyleValue & {}) | (() => import('vue').StyleValue) | ((new (...args: any[]) => import('vue').StyleValue & {}) | (() => import('vue').StyleValue))[], unknown, unknown, "", boolean>;
                    readonly wrapClass: import('element-plus/es/utils/index').EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
                    readonly viewClass: import('element-plus/es/utils/index').EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
                    readonly viewStyle: import('element-plus/es/utils/index').EpPropFinalized<readonly [StringConstructor, ArrayConstructor, ObjectConstructor], unknown, unknown, "", boolean>;
                    readonly noresize: BooleanConstructor;
                    readonly tag: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
                    readonly always: BooleanConstructor;
                    readonly minSize: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 20, boolean>;
                    readonly tabindex: import('element-plus/es/utils/index').EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, undefined, boolean>;
                    readonly id: StringConstructor;
                    readonly role: StringConstructor;
                }>> & {
                    onScroll?: ((args_0: {
                        scrollTop: number;
                        scrollLeft: number;
                    }) => 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;
                }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                    readonly height: import('element-plus/es/utils/index').EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
                    readonly maxHeight: import('element-plus/es/utils/index').EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
                    readonly always: boolean;
                    readonly tabindex: import('element-plus/es/utils/index').EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
                    readonly minSize: number;
                    readonly native: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    readonly wrapStyle: import('vue').StyleValue;
                    readonly wrapClass: import('element-plus/es/utils/index').EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
                    readonly viewClass: import('element-plus/es/utils/index').EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
                    readonly viewStyle: import('element-plus/es/utils/index').EpPropMergeType<readonly [StringConstructor, ArrayConstructor, ObjectConstructor], unknown, 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: import('vue/dist/vue.js').PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly height: import('element-plus/es/utils/index').EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
                    readonly maxHeight: import('element-plus/es/utils/index').EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
                    readonly native: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                    readonly wrapStyle: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('vue').StyleValue & {}) | (() => import('vue').StyleValue) | ((new (...args: any[]) => import('vue').StyleValue & {}) | (() => import('vue').StyleValue))[], unknown, unknown, "", boolean>;
                    readonly wrapClass: import('element-plus/es/utils/index').EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
                    readonly viewClass: import('element-plus/es/utils/index').EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
                    readonly viewStyle: import('element-plus/es/utils/index').EpPropFinalized<readonly [StringConstructor, ArrayConstructor, ObjectConstructor], unknown, unknown, "", boolean>;
                    readonly noresize: BooleanConstructor;
                    readonly tag: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
                    readonly always: BooleanConstructor;
                    readonly minSize: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 20, boolean>;
                    readonly tabindex: import('element-plus/es/utils/index').EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, undefined, boolean>;
                    readonly id: StringConstructor;
                    readonly role: StringConstructor;
                }>> & {
                    onScroll?: ((args_0: {
                        scrollTop: number;
                        scrollLeft: number;
                    }) => 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: import('element-plus/es/utils/index').EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
                    readonly maxHeight: import('element-plus/es/utils/index').EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
                    readonly always: boolean;
                    readonly tabindex: import('element-plus/es/utils/index').EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
                    readonly minSize: number;
                    readonly native: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    readonly wrapStyle: import('vue').StyleValue;
                    readonly wrapClass: import('element-plus/es/utils/index').EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
                    readonly viewClass: import('element-plus/es/utils/index').EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
                    readonly viewStyle: import('element-plus/es/utils/index').EpPropMergeType<readonly [StringConstructor, ArrayConstructor, ObjectConstructor], unknown, 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: import('vue/dist/vue.js').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly height: import('element-plus/es/utils/index').EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
                readonly maxHeight: import('element-plus/es/utils/index').EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
                readonly native: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                readonly wrapStyle: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('vue').StyleValue & {}) | (() => import('vue').StyleValue) | ((new (...args: any[]) => import('vue').StyleValue & {}) | (() => import('vue').StyleValue))[], unknown, unknown, "", boolean>;
                readonly wrapClass: import('element-plus/es/utils/index').EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
                readonly viewClass: import('element-plus/es/utils/index').EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
                readonly viewStyle: import('element-plus/es/utils/index').EpPropFinalized<readonly [StringConstructor, ArrayConstructor, ObjectConstructor], unknown, unknown, "", boolean>;
                readonly noresize: BooleanConstructor;
                readonly tag: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
                readonly always: BooleanConstructor;
                readonly minSize: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 20, boolean>;
                readonly tabindex: import('element-plus/es/utils/index').EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, undefined, boolean>;
                readonly id: StringConstructor;
                readonly role: StringConstructor;
            }>> & {
                onScroll?: ((args_0: {
                    scrollTop: number;
                    scrollLeft: number;
                }) => 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;
            }, string, {
                readonly height: import('element-plus/es/utils/index').EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
                readonly maxHeight: import('element-plus/es/utils/index').EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
                readonly always: boolean;
                readonly tabindex: import('element-plus/es/utils/index').EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
                readonly minSize: number;
                readonly native: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                readonly wrapStyle: import('vue').StyleValue;
                readonly wrapClass: import('element-plus/es/utils/index').EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
                readonly viewClass: import('element-plus/es/utils/index').EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
                readonly viewStyle: import('element-plus/es/utils/index').EpPropMergeType<readonly [StringConstructor, ArrayConstructor, ObjectConstructor], unknown, 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;
                };
            })>;
            ElCheckboxGroup: import('element-plus/es/utils/index').SFCWithInstall<{
                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                    readonly ariaLabel: StringConstructor;
                    readonly modelValue: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').CheckboxGroupValueType) | (() => import('element-plus').CheckboxGroupValueType) | ((new (...args: any[]) => import('element-plus').CheckboxGroupValueType) | (() => import('element-plus').CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;
                    readonly disabled: BooleanConstructor;
                    readonly min: NumberConstructor;
                    readonly max: NumberConstructor;
                    readonly size: {
                        readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly fill: StringConstructor;
                    readonly textColor: StringConstructor;
                    readonly tag: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
                    readonly validateEvent: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                }>> & {
                    "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: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    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: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').CheckboxGroupValueType) | (() => import('element-plus').CheckboxGroupValueType) | ((new (...args: any[]) => import('element-plus').CheckboxGroupValueType) | (() => import('element-plus').CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;
                    readonly disabled: BooleanConstructor;
                    readonly min: NumberConstructor;
                    readonly max: NumberConstructor;
                    readonly size: {
                        readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly fill: StringConstructor;
                    readonly textColor: StringConstructor;
                    readonly tag: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
                    readonly validateEvent: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                }>> & {
                    "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: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    readonly tag: string;
                }>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                readonly ariaLabel: StringConstructor;
                readonly modelValue: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').CheckboxGroupValueType) | (() => import('element-plus').CheckboxGroupValueType) | ((new (...args: any[]) => import('element-plus').CheckboxGroupValueType) | (() => import('element-plus').CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;
                readonly disabled: BooleanConstructor;
                readonly min: NumberConstructor;
                readonly max: NumberConstructor;
                readonly size: {
                    readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly fill: StringConstructor;
                readonly textColor: StringConstructor;
                readonly tag: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
                readonly validateEvent: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
            }>> & {
                "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: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                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;
                };
            })>;
            ElCheckbox: import('element-plus/es/utils/index').SFCWithInstall<{
                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: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
                        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>;
                    border: boolean;
                    disabled: 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: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
                        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>;
                    border: boolean;
                    disabled: 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: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
                    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>;
                border: boolean;
                disabled: 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;
                };
            })> & {
                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: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
                            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>;
                        border: boolean;
                        disabled: 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: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
                            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>;
                        border: boolean;
                        disabled: 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: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
                        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>;
                    border: boolean;
                    disabled: 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: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').CheckboxGroupValueType) | (() => import('element-plus').CheckboxGroupValueType) | ((new (...args: any[]) => import('element-plus').CheckboxGroupValueType) | (() => import('element-plus').CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;
                        readonly disabled: BooleanConstructor;
                        readonly min: NumberConstructor;
                        readonly max: NumberConstructor;
                        readonly size: {
                            readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly fill: StringConstructor;
                        readonly textColor: StringConstructor;
                        readonly tag: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
                        readonly validateEvent: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    }>> & {
                        "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: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                        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: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').CheckboxGroupValueType) | (() => import('element-plus').CheckboxGroupValueType) | ((new (...args: any[]) => import('element-plus').CheckboxGroupValueType) | (() => import('element-plus').CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;
                        readonly disabled: BooleanConstructor;
                        readonly min: NumberConstructor;
                        readonly max: NumberConstructor;
                        readonly size: {
                            readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly fill: StringConstructor;
                        readonly textColor: StringConstructor;
                        readonly tag: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
                        readonly validateEvent: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    }>> & {
                        "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: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                        readonly tag: string;
                    }>;
                    __isFragment?: never;
                    __isTeleport?: never;
                    __isSuspense?: never;
                } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                    readonly ariaLabel: StringConstructor;
                    readonly modelValue: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').CheckboxGroupValueType) | (() => import('element-plus').CheckboxGroupValueType) | ((new (...args: any[]) => import('element-plus').CheckboxGroupValueType) | (() => import('element-plus').CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;
                    readonly disabled: BooleanConstructor;
                    readonly min: NumberConstructor;
                    readonly max: NumberConstructor;
                    readonly size: {
                        readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly fill: StringConstructor;
                    readonly textColor: StringConstructor;
                    readonly tag: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
                    readonly validateEvent: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                }>> & {
                    "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: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    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: (StringConstructor | NumberConstructor)[];
                isPopover: BooleanConstructor;
                effect: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => string & {}) | (() => string) | ((new (...args: any[]) => string & {}) | (() => string))[], unknown, unknown, "dark", boolean>;
                ariaLabel: StringConstructor;
                placement: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, import('element-plus/es/components/popper/index').Placement, unknown, "bottom", boolean>;
                teleported: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                disabled: BooleanConstructor;
                offset: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 12, boolean>;
                persistent: BooleanConstructor;
                appendTo: {
                    readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement) | ((new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement))[], unknown, unknown>>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                zIndex: NumberConstructor;
                visible: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null) | ((new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null))[], unknown, unknown, null, boolean>;
                trigger: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType> & {}) | (() => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType>) | ((new (...args: any[]) => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType> & {}) | (() => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType>))[], unknown, unknown, "hover", boolean>;
                popperOptions: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => Partial<import('element-plus/es/components/popper/index').Options>) | (() => Partial<import('element-plus/es/components/popper/index').Options>) | ((new (...args: any[]) => Partial<import('element-plus/es/components/popper/index').Options>) | (() => Partial<import('element-plus/es/components/popper/index').Options>))[], unknown, unknown, () => {}, boolean>;
                triggerKeys: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => string[]) | (() => string[]) | ((new (...args: any[]) => string[]) | (() => string[]))[], unknown, unknown, () => string[], boolean>;
                transition: StringConstructor;
                content: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
                enterable: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                showAfter: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                hideAfter: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;
                autoClose: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                showArrow: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
                arrowOffset: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 5, boolean>;
                virtualRef: {
                    readonly type: import('vue/dist/vue.js').PropType<import('element-plus').Measurable>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                virtualTriggering: BooleanConstructor;
                rawContent: BooleanConstructor;
                gpuAcceleration: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                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<any>;
                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: (StringConstructor | NumberConstructor)[];
                isPopover: BooleanConstructor;
                effect: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => string & {}) | (() => string) | ((new (...args: any[]) => string & {}) | (() => string))[], unknown, unknown, "dark", boolean>;
                ariaLabel: StringConstructor;
                placement: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, import('element-plus/es/components/popper/index').Placement, unknown, "bottom", boolean>;
                teleported: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                disabled: BooleanConstructor;
                offset: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 12, boolean>;
                persistent: BooleanConstructor;
                appendTo: {
                    readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement) | ((new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement))[], unknown, unknown>>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                zIndex: NumberConstructor;
                visible: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null) | ((new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null))[], unknown, unknown, null, boolean>;
                trigger: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType> & {}) | (() => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType>) | ((new (...args: any[]) => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType> & {}) | (() => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType>))[], unknown, unknown, "hover", boolean>;
                popperOptions: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => Partial<import('element-plus/es/components/popper/index').Options>) | (() => Partial<import('element-plus/es/components/popper/index').Options>) | ((new (...args: any[]) => Partial<import('element-plus/es/components/popper/index').Options>) | (() => Partial<import('element-plus/es/components/popper/index').Options>))[], unknown, unknown, () => {}, boolean>;
                triggerKeys: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => string[]) | (() => string[]) | ((new (...args: any[]) => string[]) | (() => string[]))[], unknown, unknown, () => string[], boolean>;
                transition: StringConstructor;
                content: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
                enterable: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                showAfter: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                hideAfter: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;
                autoClose: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                showArrow: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
                arrowOffset: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 5, boolean>;
                virtualRef: {
                    readonly type: import('vue/dist/vue.js').PropType<import('element-plus').Measurable>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                virtualTriggering: BooleanConstructor;
                rawContent: BooleanConstructor;
                gpuAcceleration: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                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;
            }>, {
                effect: string;
                placement: string;
                teleported: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                disabled: boolean;
                offset: number;
                persistent: boolean;
                visible: import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null) | ((new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null))[], unknown, unknown>;
                trigger: import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType> & {}) | (() => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType>) | ((new (...args: any[]) => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType> & {}) | (() => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType>))[], unknown, unknown>;
                popperOptions: any;
                triggerKeys: string[];
                content: string;
                enterable: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                showAfter: number;
                hideAfter: number;
                autoClose: number;
                showArrow: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                arrowOffset: number;
                virtualTriggering: boolean;
                rawContent: boolean;
                gpuAcceleration: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                isPopover: boolean;
            }, {}, {
                ElTooltip: import('element-plus/es/utils/index').SFCWithInstall<{
                    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                        showArrow: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
                        arrowOffset: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 5, boolean>;
                        disabled: BooleanConstructor;
                        trigger: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType> & {}) | (() => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType>) | ((new (...args: any[]) => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType> & {}) | (() => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType>))[], unknown, unknown, "hover", boolean>;
                        triggerKeys: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => string[]) | (() => string[]) | ((new (...args: any[]) => string[]) | (() => string[]))[], unknown, unknown, () => string[], boolean>;
                        virtualRef: {
                            readonly type: import('vue/dist/vue.js').PropType<import('element-plus').Measurable>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        virtualTriggering: BooleanConstructor;
                        onMouseenter: {
                            readonly type: import('vue/dist/vue.js').PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onMouseleave: {
                            readonly type: import('vue/dist/vue.js').PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onClick: {
                            readonly type: import('vue/dist/vue.js').PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onKeydown: {
                            readonly type: import('vue/dist/vue.js').PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onFocus: {
                            readonly type: import('vue/dist/vue.js').PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onBlur: {
                            readonly type: import('vue/dist/vue.js').PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onContextmenu: {
                            readonly type: import('vue/dist/vue.js').PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        id: StringConstructor;
                        open: BooleanConstructor;
                        ariaLabel: StringConstructor;
                        appendTo: {
                            readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement) | ((new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement))[], unknown, unknown>>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        content: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
                        rawContent: BooleanConstructor;
                        persistent: BooleanConstructor;
                        visible: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null) | ((new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null))[], unknown, unknown, null, boolean>;
                        transition: StringConstructor;
                        teleported: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                        style: {
                            readonly type: PropType<import('vue').StyleValue>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        className: {
                            readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (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 | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | any)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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 | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | any)[])[])[])[])[])[])[])[])[])[])[]) | ((new (...args: any[]) => (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 | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | any)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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 | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | any)[])[])[])[])[])[])[])[])[])[])[]))[], unknown, unknown>>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        effect: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => string & {}) | (() => string) | ((new (...args: any[]) => string & {}) | (() => string))[], unknown, unknown, "dark", boolean>;
                        enterable: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                        pure: BooleanConstructor;
                        focusOnShow: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                        trapping: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                        popperClass: {
                            readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (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 | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | any)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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 | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | any)[])[])[])[])[])[])[])[])[])[])[]) | ((new (...args: any[]) => (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 | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | any)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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 | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | any)[])[])[])[])[])[])[])[])[])[])[]))[], unknown, unknown>>;
                            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: import('vue/dist/vue.js').PropType<HTMLElement>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        triggerTargetEl: {
                            readonly type: import('vue/dist/vue.js').PropType<HTMLElement>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        stopPopperMouseEvent: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                        zIndex: NumberConstructor;
                        boundariesPadding: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                        fallbackPlacements: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus/es/components/popper/index').Placement[]) | (() => import('element-plus/es/components/popper/index').Placement[]) | ((new (...args: any[]) => import('element-plus/es/components/popper/index').Placement[]) | (() => import('element-plus/es/components/popper/index').Placement[]))[], unknown, unknown, undefined, boolean>;
                        gpuAcceleration: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                        offset: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 12, boolean>;
                        placement: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, import('element-plus/es/components/popper/index').Placement, unknown, "bottom", boolean>;
                        popperOptions: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => Partial<import('element-plus/es/components/popper/index').Options>) | (() => Partial<import('element-plus/es/components/popper/index').Options>) | ((new (...args: any[]) => Partial<import('element-plus/es/components/popper/index').Options>) | (() => Partial<import('element-plus/es/components/popper/index').Options>))[], unknown, unknown, () => {}, boolean>;
                        strategy: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
                        showAfter: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                        hideAfter: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;
                        autoClose: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                        "onUpdate:visible": {
                            readonly type: import('vue/dist/vue.js').PropType<(val: boolean) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        role: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation", unknown, "tooltip", boolean>;
                    }>>, {
                        popperRef: import('vue').Ref<({
                            $: import('vue').ComponentInternalInstance;
                            $data: {};
                            $props: Partial<{
                                readonly role: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation", unknown>;
                            }> & Omit<Readonly<import('vue').ExtractPropTypes<{
                                readonly role: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation", unknown, "tooltip", boolean>;
                            }>> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "role">;
                            $attrs: {
                                [x: string]: unknown;
                            };
                            $refs: {
                                [x: string]: unknown;
                            };
                            $slots: Readonly<{
                                [name: string]: import('vue').Slot | undefined;
                            }>;
                            $root: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null;
                            $parent: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null;
                            $emit: (event: string, ...args: any[]) => void;
                            $el: any;
                            $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                                readonly role: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation", unknown, "tooltip", boolean>;
                            }>>, {
                                triggerRef: import('vue').Ref<import('element-plus').Measurable | undefined>;
                                contentRef: import('vue').Ref<HTMLElement | undefined>;
                                popperInstanceRef: import('vue').Ref<import('@popperjs/core').Instance | undefined>;
                                referenceRef: import('vue').Ref<import('element-plus').Measurable | undefined>;
                                role: import('vue').ComputedRef<string>;
                            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
                                readonly role: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation", unknown>;
                            }> & {
                                beforeCreate?: ((() => void) | (() => void)[]) | undefined;
                                created?: ((() => void) | (() => void)[]) | undefined;
                                beforeMount?: ((() => void) | (() => void)[]) | undefined;
                                mounted?: ((() => void) | (() => void)[]) | undefined;
                                beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
                                updated?: ((() => void) | (() => void)[]) | undefined;
                                activated?: ((() => void) | (() => void)[]) | undefined;
                                deactivated?: ((() => void) | (() => void)[]) | undefined;
                                beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
                                beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
                                destroyed?: ((() => void) | (() => void)[]) | undefined;
                                unmounted?: ((() => void) | (() => void)[]) | undefined;
                                renderTracked?: (((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[]) | undefined;
                                renderTriggered?: (((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[]) | undefined;
                                errorCaptured?: (((err: unknown, instance: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null, info: string) => boolean | void)[]) | undefined;
                            };
                            $forceUpdate: () => void;
                            $nextTick: typeof import('vue').nextTick;
                            $watch(source: string | Function, cb: Function, options?: import('vue').WatchOptions<boolean> | undefined): import('vue').WatchStopHandle;
                        } & Readonly<import('vue').ExtractPropTypes<{
                            readonly role: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation", unknown, "tooltip", boolean>;
                        }>> & import('vue').ShallowUnwrapRef<{
                            triggerRef: import('vue').Ref<import('element-plus').Measurable | undefined>;
                            contentRef: import('vue').Ref<HTMLElement | undefined>;
                            popperInstanceRef: import('vue').Ref<import('@popperjs/core').Instance | undefined>;
                            referenceRef: import('vue').Ref<import('element-plus').Measurable | undefined>;
                            role: import('vue').ComputedRef<string>;
                        }> & {} & import('vue').ComponentCustomProperties & {
                            $slots: {
                                default?(_: {}): any;
                            };
                        }) | undefined>;
                        contentRef: import('vue').Ref<any>;
                        isFocusInsideContent: (event?: FocusEvent | undefined) => boolean | undefined;
                        updatePopper: () => void;
                        onOpen: (event?: Event | undefined) => void;
                        onClose: (event?: Event | undefined) => void;
                        hide: (event?: Event | undefined) => void;
                    }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                        [x: string]: (...args: any[]) => void;
                    }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                        content: string;
                        offset: number;
                        visible: import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null) | ((new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null))[], unknown, unknown>;
                        open: boolean;
                        disabled: boolean;
                        placement: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, import('element-plus/es/components/popper/index').Placement, unknown>;
                        strategy: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "fixed" | "absolute", unknown>;
                        effect: string;
                        showAfter: number;
                        hideAfter: number;
                        autoClose: number;
                        role: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation", unknown>;
                        trigger: import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType> & {}) | (() => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType>) | ((new (...args: any[]) => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType> & {}) | (() => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType>))[], unknown, unknown>;
                        arrowOffset: number;
                        virtualTriggering: boolean;
                        boundariesPadding: number;
                        fallbackPlacements: import('element-plus/es/components/popper/index').Placement[];
                        gpuAcceleration: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                        popperOptions: Partial<import('element-plus/es/components/popper/index').Options>;
                        enterable: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                        focusOnShow: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                        trapping: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                        stopPopperMouseEvent: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                        pure: boolean;
                        triggerKeys: string[];
                        teleported: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                        rawContent: boolean;
                        persistent: boolean;
                        showArrow: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                        P: {};
                        B: {};
                        D: {};
                        C: {};
                        M: {};
                        Defaults: {};
                    }, Readonly<import('vue').ExtractPropTypes<{
                        showArrow: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
                        arrowOffset: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 5, boolean>;
                        disabled: BooleanConstructor;
                        trigger: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType> & {}) | (() => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType>) | ((new (...args: any[]) => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType> & {}) | (() => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType>))[], unknown, unknown, "hover", boolean>;
                        triggerKeys: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => string[]) | (() => string[]) | ((new (...args: any[]) => string[]) | (() => string[]))[], unknown, unknown, () => string[], boolean>;
                        virtualRef: {
                            readonly type: import('vue/dist/vue.js').PropType<import('element-plus').Measurable>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        virtualTriggering: BooleanConstructor;
                        onMouseenter: {
                            readonly type: import('vue/dist/vue.js').PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onMouseleave: {
                            readonly type: import('vue/dist/vue.js').PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onClick: {
                            readonly type: import('vue/dist/vue.js').PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onKeydown: {
                            readonly type: import('vue/dist/vue.js').PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onFocus: {
                            readonly type: import('vue/dist/vue.js').PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onBlur: {
                            readonly type: import('vue/dist/vue.js').PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onContextmenu: {
                            readonly type: import('vue/dist/vue.js').PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        id: StringConstructor;
                        open: BooleanConstructor;
                        ariaLabel: StringConstructor;
                        appendTo: {
                            readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement) | ((new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement))[], unknown, unknown>>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        content: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
                        rawContent: BooleanConstructor;
                        persistent: BooleanConstructor;
                        visible: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null) | ((new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null))[], unknown, unknown, null, boolean>;
                        transition: StringConstructor;
                        teleported: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                        style: {
                            readonly type: PropType<import('vue').StyleValue>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        className: {
                            readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (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 | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | any)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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 | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | any)[])[])[])[])[])[])[])[])[])[])[]) | ((new (...args: any[]) => (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 | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | any)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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 | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | any)[])[])[])[])[])[])[])[])[])[])[]))[], unknown, unknown>>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        effect: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => string & {}) | (() => string) | ((new (...args: any[]) => string & {}) | (() => string))[], unknown, unknown, "dark", boolean>;
                        enterable: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                        pure: BooleanConstructor;
                        focusOnShow: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                        trapping: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                        popperClass: {
                            readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (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 | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | any)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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 | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | any)[])[])[])[])[])[])[])[])[])[])[]) | ((new (...args: any[]) => (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 | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | any)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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 | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | any)[])[])[])[])[])[])[])[])[])[])[]))[], unknown, unknown>>;
                            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: import('vue/dist/vue.js').PropType<HTMLElement>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        triggerTargetEl: {
                            readonly type: import('vue/dist/vue.js').PropType<HTMLElement>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        stopPopperMouseEvent: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                        zIndex: NumberConstructor;
                        boundariesPadding: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                        fallbackPlacements: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus/es/components/popper/index').Placement[]) | (() => import('element-plus/es/components/popper/index').Placement[]) | ((new (...args: any[]) => import('element-plus/es/components/popper/index').Placement[]) | (() => import('element-plus/es/components/popper/index').Placement[]))[], unknown, unknown, undefined, boolean>;
                        gpuAcceleration: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                        offset: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 12, boolean>;
                        placement: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, import('element-plus/es/components/popper/index').Placement, unknown, "bottom", boolean>;
                        popperOptions: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => Partial<import('element-plus/es/components/popper/index').Options>) | (() => Partial<import('element-plus/es/components/popper/index').Options>) | ((new (...args: any[]) => Partial<import('element-plus/es/components/popper/index').Options>) | (() => Partial<import('element-plus/es/components/popper/index').Options>))[], unknown, unknown, () => {}, boolean>;
                        strategy: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
                        showAfter: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                        hideAfter: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;
                        autoClose: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                        "onUpdate:visible": {
                            readonly type: import('vue/dist/vue.js').PropType<(val: boolean) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        role: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation", unknown, "tooltip", boolean>;
                    }>>, {
                        popperRef: import('vue').Ref<({
                            $: import('vue').ComponentInternalInstance;
                            $data: {};
                            $props: Partial<{
                                readonly role: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation", unknown>;
                            }> & Omit<Readonly<import('vue').ExtractPropTypes<{
                                readonly role: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation", unknown, "tooltip", boolean>;
                            }>> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "role">;
                            $attrs: {
                                [x: string]: unknown;
                            };
                            $refs: {
                                [x: string]: unknown;
                            };
                            $slots: Readonly<{
                                [name: string]: import('vue').Slot | undefined;
                            }>;
                            $root: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null;
                            $parent: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null;
                            $emit: (event: string, ...args: any[]) => void;
                            $el: any;
                            $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                                readonly role: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation", unknown, "tooltip", boolean>;
                            }>>, {
                                triggerRef: import('vue').Ref<import('element-plus').Measurable | undefined>;
                                contentRef: import('vue').Ref<HTMLElement | undefined>;
                                popperInstanceRef: import('vue').Ref<import('@popperjs/core').Instance | undefined>;
                                referenceRef: import('vue').Ref<import('element-plus').Measurable | undefined>;
                                role: import('vue').ComputedRef<string>;
                            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
                                readonly role: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation", unknown>;
                            }> & {
                                beforeCreate?: ((() => void) | (() => void)[]) | undefined;
                                created?: ((() => void) | (() => void)[]) | undefined;
                                beforeMount?: ((() => void) | (() => void)[]) | undefined;
                                mounted?: ((() => void) | (() => void)[]) | undefined;
                                beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
                                updated?: ((() => void) | (() => void)[]) | undefined;
                                activated?: ((() => void) | (() => void)[]) | undefined;
                                deactivated?: ((() => void) | (() => void)[]) | undefined;
                                beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
                                beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
                                destroyed?: ((() => void) | (() => void)[]) | undefined;
                                unmounted?: ((() => void) | (() => void)[]) | undefined;
                                renderTracked?: (((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[]) | undefined;
                                renderTriggered?: (((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[]) | undefined;
                                errorCaptured?: (((err: unknown, instance: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null, info: string) => boolean | void)[]) | undefined;
                            };
                            $forceUpdate: () => void;
                            $nextTick: typeof import('vue').nextTick;
                            $watch(source: string | Function, cb: Function, options?: import('vue').WatchOptions<boolean> | undefined): import('vue').WatchStopHandle;
                        } & Readonly<import('vue').ExtractPropTypes<{
                            readonly role: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation", unknown, "tooltip", boolean>;
                        }>> & import('vue').ShallowUnwrapRef<{
                            triggerRef: import('vue').Ref<import('element-plus').Measurable | undefined>;
                            contentRef: import('vue').Ref<HTMLElement | undefined>;
                            popperInstanceRef: import('vue').Ref<import('@popperjs/core').Instance | undefined>;
                            referenceRef: import('vue').Ref<import('element-plus').Measurable | undefined>;
                            role: import('vue').ComputedRef<string>;
                        }> & {} & import('vue').ComponentCustomProperties & {
                            $slots: {
                                default?(_: {}): any;
                            };
                        }) | undefined>;
                        contentRef: import('vue').Ref<any>;
                        isFocusInsideContent: (event?: FocusEvent | undefined) => boolean | undefined;
                        updatePopper: () => void;
                        onOpen: (event?: Event | undefined) => void;
                        onClose: (event?: Event | undefined) => void;
                        hide: (event?: Event | undefined) => void;
                    }, {}, {}, {}, {
                        content: string;
                        offset: number;
                        visible: import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null) | ((new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null))[], unknown, unknown>;
                        open: boolean;
                        disabled: boolean;
                        placement: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, import('element-plus/es/components/popper/index').Placement, unknown>;
                        strategy: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "fixed" | "absolute", unknown>;
                        effect: string;
                        showAfter: number;
                        hideAfter: number;
                        autoClose: number;
                        role: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation", unknown>;
                        trigger: import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType> & {}) | (() => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType>) | ((new (...args: any[]) => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType> & {}) | (() => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType>))[], unknown, unknown>;
                        arrowOffset: number;
                        virtualTriggering: boolean;
                        boundariesPadding: number;
                        fallbackPlacements: import('element-plus/es/components/popper/index').Placement[];
                        gpuAcceleration: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                        popperOptions: Partial<import('element-plus/es/components/popper/index').Options>;
                        enterable: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                        focusOnShow: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                        trapping: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                        stopPopperMouseEvent: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                        pure: boolean;
                        triggerKeys: string[];
                        teleported: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                        rawContent: boolean;
                        persistent: boolean;
                        showArrow: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    }>;
                    __isFragment?: never;
                    __isTeleport?: never;
                    __isSuspense?: never;
                } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                    showArrow: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
                    arrowOffset: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 5, boolean>;
                    disabled: BooleanConstructor;
                    trigger: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType> & {}) | (() => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType>) | ((new (...args: any[]) => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType> & {}) | (() => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType>))[], unknown, unknown, "hover", boolean>;
                    triggerKeys: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => string[]) | (() => string[]) | ((new (...args: any[]) => string[]) | (() => string[]))[], unknown, unknown, () => string[], boolean>;
                    virtualRef: {
                        readonly type: import('vue/dist/vue.js').PropType<import('element-plus').Measurable>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    virtualTriggering: BooleanConstructor;
                    onMouseenter: {
                        readonly type: import('vue/dist/vue.js').PropType<(e: Event) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    onMouseleave: {
                        readonly type: import('vue/dist/vue.js').PropType<(e: Event) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    onClick: {
                        readonly type: import('vue/dist/vue.js').PropType<(e: Event) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    onKeydown: {
                        readonly type: import('vue/dist/vue.js').PropType<(e: Event) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    onFocus: {
                        readonly type: import('vue/dist/vue.js').PropType<(e: Event) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    onBlur: {
                        readonly type: import('vue/dist/vue.js').PropType<(e: Event) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    onContextmenu: {
                        readonly type: import('vue/dist/vue.js').PropType<(e: Event) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    id: StringConstructor;
                    open: BooleanConstructor;
                    ariaLabel: StringConstructor;
                    appendTo: {
                        readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement) | ((new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement))[], unknown, unknown>>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    content: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
                    rawContent: BooleanConstructor;
                    persistent: BooleanConstructor;
                    visible: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null) | ((new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null))[], unknown, unknown, null, boolean>;
                    transition: StringConstructor;
                    teleported: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    style: {
                        readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => import('vue').StyleValue & {}) | (() => import('vue').StyleValue) | ((new (...args: any[]) => import('vue').StyleValue & {}) | (() => import('vue').StyleValue))[], unknown, unknown>>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    className: {
                        readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (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 | {
                            [x: string]: boolean;
                        } | (string | {
                            [x: string]: boolean;
                        } | any)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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 | {
                            [x: string]: boolean;
                        } | (string | {
                            [x: string]: boolean;
                        } | any)[])[])[])[])[])[])[])[])[])[])[]) | ((new (...args: any[]) => (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 | {
                            [x: string]: boolean;
                        } | (string | {
                            [x: string]: boolean;
                        } | any)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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 | {
                            [x: string]: boolean;
                        } | (string | {
                            [x: string]: boolean;
                        } | any)[])[])[])[])[])[])[])[])[])[])[]))[], unknown, unknown>>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    effect: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => string & {}) | (() => string) | ((new (...args: any[]) => string & {}) | (() => string))[], unknown, unknown, "dark", boolean>;
                    enterable: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    pure: BooleanConstructor;
                    focusOnShow: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                    trapping: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                    popperClass: {
                        readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (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 | {
                            [x: string]: boolean;
                        } | (string | {
                            [x: string]: boolean;
                        } | any)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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 | {
                            [x: string]: boolean;
                        } | (string | {
                            [x: string]: boolean;
                        } | any)[])[])[])[])[])[])[])[])[])[])[]) | ((new (...args: any[]) => (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 | {
                            [x: string]: boolean;
                        } | (string | {
                            [x: string]: boolean;
                        } | any)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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 | {
                            [x: string]: boolean;
                        } | (string | {
                            [x: string]: boolean;
                        } | any)[])[])[])[])[])[])[])[])[])[])[]))[], unknown, unknown>>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    popperStyle: {
                        readonly type: import('vue/dist/vue.js').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => import('vue').StyleValue & {}) | (() => import('vue').StyleValue) | ((new (...args: any[]) => import('vue').StyleValue & {}) | (() => import('vue').StyleValue))[], unknown, unknown>>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    referenceEl: {
                        readonly type: import('vue/dist/vue.js').PropType<HTMLElement>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    triggerTargetEl: {
                        readonly type: import('vue/dist/vue.js').PropType<HTMLElement>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    stopPopperMouseEvent: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    zIndex: NumberConstructor;
                    boundariesPadding: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                    fallbackPlacements: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus/es/components/popper/index').Placement[]) | (() => import('element-plus/es/components/popper/index').Placement[]) | ((new (...args: any[]) => import('element-plus/es/components/popper/index').Placement[]) | (() => import('element-plus/es/components/popper/index').Placement[]))[], unknown, unknown, undefined, boolean>;
                    gpuAcceleration: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    offset: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 12, boolean>;
                    placement: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, import('element-plus/es/components/popper/index').Placement, unknown, "bottom", boolean>;
                    popperOptions: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => Partial<import('element-plus/es/components/popper/index').Options>) | (() => Partial<import('element-plus/es/components/popper/index').Options>) | ((new (...args: any[]) => Partial<import('element-plus/es/components/popper/index').Options>) | (() => Partial<import('element-plus/es/components/popper/index').Options>))[], unknown, unknown, () => {}, boolean>;
                    strategy: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
                    showAfter: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                    hideAfter: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;
                    autoClose: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                    "onUpdate:visible": {
                        readonly type: import('vue/dist/vue.js').PropType<(val: boolean) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    role: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation", unknown, "tooltip", boolean>;
                }>>, {
                    popperRef: import('vue').Ref<({
                        $: import('vue').ComponentInternalInstance;
                        $data: {};
                        $props: Partial<{
                            readonly role: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation", unknown>;
                        }> & Omit<Readonly<import('vue').ExtractPropTypes<{
                            readonly role: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation", unknown, "tooltip", boolean>;
                        }>> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "role">;
                        $attrs: {
                            [x: string]: unknown;
                        };
                        $refs: {
                            [x: string]: unknown;
                        };
                        $slots: Readonly<{
                            [name: string]: import('vue').Slot | undefined;
                        }>;
                        $root: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null;
                        $parent: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null;
                        $emit: (event: string, ...args: any[]) => void;
                        $el: any;
                        $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                            readonly role: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation", unknown, "tooltip", boolean>;
                        }>>, {
                            triggerRef: import('vue').Ref<import('element-plus').Measurable | undefined>;
                            contentRef: import('vue').Ref<HTMLElement | undefined>;
                            popperInstanceRef: import('vue').Ref<import('@popperjs/core').Instance | undefined>;
                            referenceRef: import('vue').Ref<import('element-plus').Measurable | undefined>;
                            role: import('vue').ComputedRef<string>;
                        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
                            readonly role: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation", unknown>;
                        }> & {
                            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
                            created?: ((() => void) | (() => void)[]) | undefined;
                            beforeMount?: ((() => void) | (() => void)[]) | undefined;
                            mounted?: ((() => void) | (() => void)[]) | undefined;
                            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
                            updated?: ((() => void) | (() => void)[]) | undefined;
                            activated?: ((() => void) | (() => void)[]) | undefined;
                            deactivated?: ((() => void) | (() => void)[]) | undefined;
                            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
                            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
                            destroyed?: ((() => void) | (() => void)[]) | undefined;
                            unmounted?: ((() => void) | (() => void)[]) | undefined;
                            renderTracked?: (((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[]) | undefined;
                            renderTriggered?: (((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[]) | undefined;
                            errorCaptured?: (((err: unknown, instance: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null, info: string) => boolean | void)[]) | undefined;
                        };
                        $forceUpdate: () => void;
                        $nextTick: typeof import('vue').nextTick;
                        $watch(source: string | Function, cb: Function, options?: import('vue').WatchOptions<boolean> | undefined): import('vue').WatchStopHandle;
                    } & Readonly<import('vue').ExtractPropTypes<{
                        readonly role: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation", unknown, "tooltip", boolean>;
                    }>> & import('vue').ShallowUnwrapRef<{
                        triggerRef: import('vue').Ref<import('element-plus').Measurable | undefined>;
                        contentRef: import('vue').Ref<HTMLElement | undefined>;
                        popperInstanceRef: import('vue').Ref<import('@popperjs/core').Instance | undefined>;
                        referenceRef: import('vue').Ref<import('element-plus').Measurable | undefined>;
                        role: import('vue').ComputedRef<string>;
                    }> & {} & import('vue').ComponentCustomProperties & {
                        $slots: {
                            default?(_: {}): any;
                        };
                    }) | undefined>;
                    contentRef: import('vue').Ref<any>;
                    isFocusInsideContent: (event?: FocusEvent | undefined) => boolean | undefined;
                    updatePopper: () => void;
                    onOpen: (event?: Event | undefined) => void;
                    onClose: (event?: Event | undefined) => void;
                    hide: (event?: Event | undefined) => void;
                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                    [x: string]: (...args: any[]) => void;
                }, string, {
                    content: string;
                    offset: number;
                    visible: import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null) | ((new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null))[], unknown, unknown>;
                    open: boolean;
                    disabled: boolean;
                    placement: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, import('element-plus/es/components/popper/index').Placement, unknown>;
                    strategy: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "fixed" | "absolute", unknown>;
                    effect: string;
                    showAfter: number;
                    hideAfter: number;
                    autoClose: number;
                    role: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation", unknown>;
                    trigger: import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType> & {}) | (() => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType>) | ((new (...args: any[]) => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType> & {}) | (() => import('element-plus/es/utils/typescript').Arrayable<import('element-plus').TooltipTriggerType>))[], unknown, unknown>;
                    arrowOffset: number;
                    virtualTriggering: boolean;
                    boundariesPadding: number;
                    fallbackPlacements: import('element-plus/es/components/popper/index').Placement[];
                    gpuAcceleration: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    popperOptions: Partial<import('element-plus/es/components/popper/index').Options>;
                    enterable: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    focusOnShow: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    trapping: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    stopPopperMouseEvent: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    pure: boolean;
                    triggerKeys: string[];
                    teleported: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    rawContent: boolean;
                    persistent: boolean;
                    showArrow: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
                }, {}, 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;
                    };
                })>;
            }, {}, 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 import('../util').CellRender;
    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
export default _default;