import { PropType } from 'vue';
import { DataKey, DataItem, Column, TableSize, CellClass, CellStyle, SpanMethod, ShowOverflowTooltip, TableLoad } from '../../ele-data-table/types';
import { BodyColumns, ColSize, VirtualRow } from '../types';

declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
    /** 主体列配置 */
    bodyCols: {
        type: PropType<BodyColumns>;
        required: true;
    };
    /** 表格主体列宽 */
    colSizes: {
        type: PropType<ColSize[]>;
        required: true;
    };
    /** 当前行索引 */
    rowIndex: {
        type: NumberConstructor;
        required: true;
    };
    /** 当前行对象 */
    rowItem: {
        type: PropType<VirtualRow>;
        required: true;
    };
    /** 当前行数据唯一值 */
    rowId: PropType<DataKey>;
    /** 表格多选选中的值 */
    checkedRowKeys: PropType<Set<DataKey>>;
    /** 单元格类名自定义 */
    bodyCellClass: PropType<CellClass>;
    /** 单元格样式自定义 */
    bodyCellStyle: PropType<CellStyle>;
    /** 单元格合并行列方法 */
    spanMethod: PropType<SpanMethod>;
    /** 溢出提示组件全局属性 */
    tableTooltipProps: PropType<ShowOverflowTooltip>;
    /** 序号列起始编号 */
    pageIndex: NumberConstructor;
    /** 表格行高 */
    rowHeight: NumberConstructor;
    /** 表格尺寸 */
    tableSize: PropType<TableSize>;
    /** 树表格展开图标的列 */
    expandColumnKey: StringConstructor;
    /** 表格展开行的值 */
    expandedRowKeys: PropType<DataKey[]>;
    /** 树表格是否懒加载子级 */
    lazy: BooleanConstructor;
    /** 树表格懒加载方法 */
    load: PropType<TableLoad>;
    /** 树表格行数据缩进级别 */
    level: NumberConstructor;
    /** 树表格每一级行缩进大小 */
    indent: NumberConstructor;
    /** 是否需要固定单元格高度 */
    fixedCellHeight: BooleanConstructor;
    /** 表格是否是自适应行高 */
    autoRowHeight: BooleanConstructor;
}>, {
    loading: import('vue').Ref<boolean, boolean>;
    isChecked: import('vue').ComputedRef<boolean>;
    hasChildren: import('vue').ComputedRef<boolean>;
    rowIndent: import('vue').ComputedRef<string | undefined>;
    isCollapse: import('vue').ComputedRef<boolean>;
    handleCellCheckedChange: (checked: boolean) => void;
    handleCellExpandChange: (expanded: boolean) => void;
    handleCellClick: (col: Column, e: MouseEvent) => void;
    handleCellDblclick: (col: Column, e: MouseEvent) => void;
    handleCellContextmenu: (col: Column, e: MouseEvent) => void;
    handleCellMouseenter: (col: Column, e: MouseEvent) => void;
    handleCellMouseleave: (col: Column, e: MouseEvent) => void;
}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
    /** 多选框选中改变事件 */
    cellCheckedChange: (_row: VirtualRow, _checked: boolean) => true;
    /** 展开状态改变事件 */
    cellExpandChange: (_row: VirtualRow, _expanded: boolean, _children?: DataItem[]) => true;
    /** 单元格点击事件 */
    cellClick: (_row: VirtualRow, _col: Column, _e: MouseEvent) => true;
    /** 单元格双击事件 */
    cellDblclick: (_row: VirtualRow, _col: Column, _e: MouseEvent) => true;
    /** 单元格右键事件 */
    cellContextmenu: (_row: VirtualRow, _col: Column, _e: MouseEvent) => true;
    /** 单元格鼠标移入事件 */
    cellMouseenter: (_row: VirtualRow, _col: Column, _e: MouseEvent) => true;
    /** 单元格鼠标移出事件 */
    cellMouseleave: (_row: VirtualRow, _col: Column, _e: MouseEvent) => true;
}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
    /** 主体列配置 */
    bodyCols: {
        type: PropType<BodyColumns>;
        required: true;
    };
    /** 表格主体列宽 */
    colSizes: {
        type: PropType<ColSize[]>;
        required: true;
    };
    /** 当前行索引 */
    rowIndex: {
        type: NumberConstructor;
        required: true;
    };
    /** 当前行对象 */
    rowItem: {
        type: PropType<VirtualRow>;
        required: true;
    };
    /** 当前行数据唯一值 */
    rowId: PropType<DataKey>;
    /** 表格多选选中的值 */
    checkedRowKeys: PropType<Set<DataKey>>;
    /** 单元格类名自定义 */
    bodyCellClass: PropType<CellClass>;
    /** 单元格样式自定义 */
    bodyCellStyle: PropType<CellStyle>;
    /** 单元格合并行列方法 */
    spanMethod: PropType<SpanMethod>;
    /** 溢出提示组件全局属性 */
    tableTooltipProps: PropType<ShowOverflowTooltip>;
    /** 序号列起始编号 */
    pageIndex: NumberConstructor;
    /** 表格行高 */
    rowHeight: NumberConstructor;
    /** 表格尺寸 */
    tableSize: PropType<TableSize>;
    /** 树表格展开图标的列 */
    expandColumnKey: StringConstructor;
    /** 表格展开行的值 */
    expandedRowKeys: PropType<DataKey[]>;
    /** 树表格是否懒加载子级 */
    lazy: BooleanConstructor;
    /** 树表格懒加载方法 */
    load: PropType<TableLoad>;
    /** 树表格行数据缩进级别 */
    level: NumberConstructor;
    /** 树表格每一级行缩进大小 */
    indent: NumberConstructor;
    /** 是否需要固定单元格高度 */
    fixedCellHeight: BooleanConstructor;
    /** 表格是否是自适应行高 */
    autoRowHeight: BooleanConstructor;
}>> & Readonly<{
    onCellClick?: ((_row: VirtualRow, _col: Column, _e: MouseEvent) => any) | undefined;
    onCellDblclick?: ((_row: VirtualRow, _col: Column, _e: MouseEvent) => any) | undefined;
    onCellContextmenu?: ((_row: VirtualRow, _col: Column, _e: MouseEvent) => any) | undefined;
    onCellMouseenter?: ((_row: VirtualRow, _col: Column, _e: MouseEvent) => any) | undefined;
    onCellCheckedChange?: ((_row: VirtualRow, _checked: boolean) => any) | undefined;
    onCellExpandChange?: ((_row: VirtualRow, _expanded: boolean, _children?: DataItem[] | undefined) => any) | undefined;
    onCellMouseleave?: ((_row: VirtualRow, _col: Column, _e: MouseEvent) => any) | undefined;
}>, {
    lazy: boolean;
    fixedCellHeight: boolean;
    autoRowHeight: boolean;
}, {}, {
    BodyCell: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        column: {
            type: PropType<import('../types').BodyColumn>;
            required: true;
        };
        columnIndex: {
            type: NumberConstructor;
            required: true;
        };
        rowIndex: {
            type: NumberConstructor;
            required: true;
        };
        rowData: {
            type: PropType<DataItem>;
            required: true;
        };
        colSizes: {
            type: PropType<ColSize[]>;
            required: true;
        };
        bodyCellClass: PropType<CellClass>;
        bodyCellStyle: PropType<CellStyle>;
        spanMethod: PropType<SpanMethod>;
        tableTooltipProps: PropType<ShowOverflowTooltip>;
        pageIndex: NumberConstructor;
        rowHeight: NumberConstructor;
        isChecked: BooleanConstructor;
        isDisabled: BooleanConstructor;
        tableSize: PropType<TableSize>;
        expandColumnKey: StringConstructor;
        hasChildren: BooleanConstructor;
        rowIndent: StringConstructor;
        isCollapse: BooleanConstructor;
        loading: BooleanConstructor;
        fixedCellHeight: BooleanConstructor;
        autoRowHeight: BooleanConstructor;
    }>, {
        colType: import('vue').ComputedRef<string>;
        cellClass: import('vue').ComputedRef<string>;
        cellStyle: import('vue').ComputedRef<import('../../ele-app/types').StyleValues | undefined>;
        cellText: import('vue').ComputedRef<string | undefined>;
        isExpandCol: import('vue').ComputedRef<boolean>;
        renderOpt: import('vue').ComputedRef<import('../types').CustomRenderProps>;
        handleTextClick: (e: MouseEvent) => void;
        handleCheckedChange: (checked: boolean) => void;
        handleExpandChange: () => void;
        handleClick: (e: MouseEvent) => void;
        handleDblclick: (e: MouseEvent) => void;
        handleContextmenu: (e: MouseEvent) => void;
        handleMouseenter: (e: MouseEvent) => void;
        handleMouseleave: (e: MouseEvent) => void;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
        checkedChange: (_checked: boolean) => true;
        expandChange: (_expanded: boolean) => true;
        click: (_col: Column, _e: MouseEvent) => true;
        dblclick: (_col: Column, _e: MouseEvent) => true;
        contextmenu: (_col: Column, _e: MouseEvent) => true;
        mouseenter: (_col: Column, _e: MouseEvent) => true;
        mouseleave: (_col: Column, _e: MouseEvent) => true;
    }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        column: {
            type: PropType<import('../types').BodyColumn>;
            required: true;
        };
        columnIndex: {
            type: NumberConstructor;
            required: true;
        };
        rowIndex: {
            type: NumberConstructor;
            required: true;
        };
        rowData: {
            type: PropType<DataItem>;
            required: true;
        };
        colSizes: {
            type: PropType<ColSize[]>;
            required: true;
        };
        bodyCellClass: PropType<CellClass>;
        bodyCellStyle: PropType<CellStyle>;
        spanMethod: PropType<SpanMethod>;
        tableTooltipProps: PropType<ShowOverflowTooltip>;
        pageIndex: NumberConstructor;
        rowHeight: NumberConstructor;
        isChecked: BooleanConstructor;
        isDisabled: BooleanConstructor;
        tableSize: PropType<TableSize>;
        expandColumnKey: StringConstructor;
        hasChildren: BooleanConstructor;
        rowIndent: StringConstructor;
        isCollapse: BooleanConstructor;
        loading: BooleanConstructor;
        fixedCellHeight: BooleanConstructor;
        autoRowHeight: BooleanConstructor;
    }>> & Readonly<{
        onClick?: ((_col: Column, _e: MouseEvent) => any) | undefined;
        onContextmenu?: ((_col: Column, _e: MouseEvent) => any) | undefined;
        onDblclick?: ((_col: Column, _e: MouseEvent) => any) | undefined;
        onMouseenter?: ((_col: Column, _e: MouseEvent) => any) | undefined;
        onMouseleave?: ((_col: Column, _e: MouseEvent) => any) | undefined;
        onExpandChange?: ((_expanded: boolean) => any) | undefined;
        onCheckedChange?: ((_checked: boolean) => any) | undefined;
    }>, {
        loading: boolean;
        isCollapse: boolean;
        isChecked: boolean;
        isDisabled: boolean;
        hasChildren: boolean;
        fixedCellHeight: boolean;
        autoRowHeight: boolean;
    }, {}, {
        ElIcon: {
            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                readonly size: {
                    readonly type: PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly color: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import('vue').ExtractPropTypes<{
                readonly size: {
                    readonly type: PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly color: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {}, {}, {}, {}, {}>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
            readonly size: {
                readonly type: PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly color: {
                readonly type: PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
        }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
            $slots: {
                default?(_: {}): any;
            };
        }) & import('vue').Plugin;
        ArrowDown: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        LoadingDotOutlined: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        CellCheckbox: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
            checked: BooleanConstructor;
            indeterminate: BooleanConstructor;
            disabled: BooleanConstructor;
            size: PropType<TableSize>;
        }>, {
            handleUpdateModelValue: (modelValue: boolean) => void;
        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
            change: (_checked: boolean) => true;
        }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
            checked: BooleanConstructor;
            indeterminate: BooleanConstructor;
            disabled: BooleanConstructor;
            size: PropType<TableSize>;
        }>> & Readonly<{
            onChange?: ((_checked: boolean) => any) | undefined;
        }>, {
            disabled: boolean;
            indeterminate: boolean;
            checked: boolean;
        }, {}, {
            ElCheckbox: ({
                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                    ariaControls: StringConstructor;
                    modelValue: {
                        type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
                        default: undefined;
                    };
                    label: {
                        type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
                        default: undefined;
                    };
                    value: {
                        type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
                        default: undefined;
                    };
                    indeterminate: BooleanConstructor;
                    disabled: BooleanConstructor;
                    checked: BooleanConstructor;
                    name: {
                        type: StringConstructor;
                        default: undefined;
                    };
                    trueValue: {
                        type: (NumberConstructor | StringConstructor)[];
                        default: undefined;
                    };
                    falseValue: {
                        type: (NumberConstructor | StringConstructor)[];
                        default: undefined;
                    };
                    trueLabel: {
                        type: (NumberConstructor | StringConstructor)[];
                        default: undefined;
                    };
                    falseLabel: {
                        type: (NumberConstructor | StringConstructor)[];
                        default: undefined;
                    };
                    id: {
                        type: StringConstructor;
                        default: undefined;
                    };
                    border: BooleanConstructor;
                    size: {
                        readonly type: PropType<"" | "small" | "default" | "large">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    tabindex: (NumberConstructor | StringConstructor)[];
                    validateEvent: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>> & {
                    "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
                    onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
                }, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                    "update:modelValue": (val: import('element-plus').CheckboxValueType) => void;
                    change: (val: import('element-plus').CheckboxValueType) => void;
                }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                    label: string | number | boolean | Record<string, any>;
                    disabled: boolean;
                    border: boolean;
                    value: string | number | boolean | Record<string, any>;
                    id: string;
                    name: string;
                    modelValue: string | number | boolean;
                    validateEvent: boolean;
                    indeterminate: boolean;
                    checked: boolean;
                    trueValue: string | number;
                    falseValue: string | number;
                    trueLabel: string | number;
                    falseLabel: string | number;
                }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import('vue').ExtractPropTypes<{
                    ariaControls: StringConstructor;
                    modelValue: {
                        type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
                        default: undefined;
                    };
                    label: {
                        type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
                        default: undefined;
                    };
                    value: {
                        type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
                        default: undefined;
                    };
                    indeterminate: BooleanConstructor;
                    disabled: BooleanConstructor;
                    checked: BooleanConstructor;
                    name: {
                        type: StringConstructor;
                        default: undefined;
                    };
                    trueValue: {
                        type: (NumberConstructor | StringConstructor)[];
                        default: undefined;
                    };
                    falseValue: {
                        type: (NumberConstructor | StringConstructor)[];
                        default: undefined;
                    };
                    trueLabel: {
                        type: (NumberConstructor | StringConstructor)[];
                        default: undefined;
                    };
                    falseLabel: {
                        type: (NumberConstructor | StringConstructor)[];
                        default: undefined;
                    };
                    id: {
                        type: StringConstructor;
                        default: undefined;
                    };
                    border: BooleanConstructor;
                    size: {
                        readonly type: PropType<"" | "small" | "default" | "large">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    tabindex: (NumberConstructor | StringConstructor)[];
                    validateEvent: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>> & {
                    "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
                    onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
                }, {}, {}, {}, {}, {
                    label: string | number | boolean | Record<string, any>;
                    disabled: boolean;
                    border: boolean;
                    value: string | number | boolean | Record<string, any>;
                    id: string;
                    name: string;
                    modelValue: string | number | boolean;
                    validateEvent: boolean;
                    indeterminate: boolean;
                    checked: boolean;
                    trueValue: string | number;
                    falseValue: string | number;
                    trueLabel: string | number;
                    falseLabel: string | number;
                }>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                ariaControls: StringConstructor;
                modelValue: {
                    type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
                    default: undefined;
                };
                label: {
                    type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
                    default: undefined;
                };
                value: {
                    type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
                    default: undefined;
                };
                indeterminate: BooleanConstructor;
                disabled: BooleanConstructor;
                checked: BooleanConstructor;
                name: {
                    type: StringConstructor;
                    default: undefined;
                };
                trueValue: {
                    type: (NumberConstructor | StringConstructor)[];
                    default: undefined;
                };
                falseValue: {
                    type: (NumberConstructor | StringConstructor)[];
                    default: undefined;
                };
                trueLabel: {
                    type: (NumberConstructor | StringConstructor)[];
                    default: undefined;
                };
                falseLabel: {
                    type: (NumberConstructor | StringConstructor)[];
                    default: undefined;
                };
                id: {
                    type: StringConstructor;
                    default: undefined;
                };
                border: BooleanConstructor;
                size: {
                    readonly type: PropType<"" | "small" | "default" | "large">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                tabindex: (NumberConstructor | StringConstructor)[];
                validateEvent: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & {
                "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
                onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
            }, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                "update:modelValue": (val: import('element-plus').CheckboxValueType) => void;
                change: (val: import('element-plus').CheckboxValueType) => void;
            }, string, {
                label: string | number | boolean | Record<string, any>;
                disabled: boolean;
                border: boolean;
                value: string | number | boolean | Record<string, any>;
                id: string;
                name: string;
                modelValue: string | number | boolean;
                validateEvent: boolean;
                indeterminate: boolean;
                checked: boolean;
                trueValue: string | number;
                falseValue: string | number;
                trueLabel: string | number;
                falseLabel: string | number;
            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
                $slots: {
                    default?(_: {}): any;
                };
            }) & import('vue').Plugin) & {
                CheckboxButton: {
                    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                        ariaControls: StringConstructor;
                        modelValue: {
                            type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
                            default: undefined;
                        };
                        label: {
                            type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
                            default: undefined;
                        };
                        value: {
                            type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
                            default: undefined;
                        };
                        indeterminate: BooleanConstructor;
                        disabled: BooleanConstructor;
                        checked: BooleanConstructor;
                        name: {
                            type: StringConstructor;
                            default: undefined;
                        };
                        trueValue: {
                            type: (NumberConstructor | StringConstructor)[];
                            default: undefined;
                        };
                        falseValue: {
                            type: (NumberConstructor | StringConstructor)[];
                            default: undefined;
                        };
                        trueLabel: {
                            type: (NumberConstructor | StringConstructor)[];
                            default: undefined;
                        };
                        falseLabel: {
                            type: (NumberConstructor | StringConstructor)[];
                            default: undefined;
                        };
                        id: {
                            type: StringConstructor;
                            default: undefined;
                        };
                        border: BooleanConstructor;
                        size: {
                            readonly type: PropType<"" | "small" | "default" | "large">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        tabindex: (NumberConstructor | StringConstructor)[];
                        validateEvent: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                    }>> & {
                        "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
                        onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
                    }, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                        "update:modelValue": (val: import('element-plus').CheckboxValueType) => void;
                        change: (val: import('element-plus').CheckboxValueType) => void;
                    }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                        label: string | number | boolean | Record<string, any>;
                        disabled: boolean;
                        border: boolean;
                        value: string | number | boolean | Record<string, any>;
                        id: string;
                        name: string;
                        modelValue: string | number | boolean;
                        validateEvent: boolean;
                        indeterminate: boolean;
                        checked: boolean;
                        trueValue: string | number;
                        falseValue: string | number;
                        trueLabel: string | number;
                        falseLabel: string | number;
                    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                        P: {};
                        B: {};
                        D: {};
                        C: {};
                        M: {};
                        Defaults: {};
                    }, Readonly<import('vue').ExtractPropTypes<{
                        ariaControls: StringConstructor;
                        modelValue: {
                            type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
                            default: undefined;
                        };
                        label: {
                            type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
                            default: undefined;
                        };
                        value: {
                            type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
                            default: undefined;
                        };
                        indeterminate: BooleanConstructor;
                        disabled: BooleanConstructor;
                        checked: BooleanConstructor;
                        name: {
                            type: StringConstructor;
                            default: undefined;
                        };
                        trueValue: {
                            type: (NumberConstructor | StringConstructor)[];
                            default: undefined;
                        };
                        falseValue: {
                            type: (NumberConstructor | StringConstructor)[];
                            default: undefined;
                        };
                        trueLabel: {
                            type: (NumberConstructor | StringConstructor)[];
                            default: undefined;
                        };
                        falseLabel: {
                            type: (NumberConstructor | StringConstructor)[];
                            default: undefined;
                        };
                        id: {
                            type: StringConstructor;
                            default: undefined;
                        };
                        border: BooleanConstructor;
                        size: {
                            readonly type: PropType<"" | "small" | "default" | "large">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        tabindex: (NumberConstructor | StringConstructor)[];
                        validateEvent: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                    }>> & {
                        "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
                        onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
                    }, {}, {}, {}, {}, {
                        label: string | number | boolean | Record<string, any>;
                        disabled: boolean;
                        border: boolean;
                        value: string | number | boolean | Record<string, any>;
                        id: string;
                        name: string;
                        modelValue: string | number | boolean;
                        validateEvent: boolean;
                        indeterminate: boolean;
                        checked: boolean;
                        trueValue: string | number;
                        falseValue: string | number;
                        trueLabel: string | number;
                        falseLabel: string | number;
                    }>;
                    __isFragment?: never;
                    __isTeleport?: never;
                    __isSuspense?: never;
                } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                    ariaControls: StringConstructor;
                    modelValue: {
                        type: (NumberConstructor | StringConstructor | BooleanConstructor)[];
                        default: undefined;
                    };
                    label: {
                        type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
                        default: undefined;
                    };
                    value: {
                        type: (ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[];
                        default: undefined;
                    };
                    indeterminate: BooleanConstructor;
                    disabled: BooleanConstructor;
                    checked: BooleanConstructor;
                    name: {
                        type: StringConstructor;
                        default: undefined;
                    };
                    trueValue: {
                        type: (NumberConstructor | StringConstructor)[];
                        default: undefined;
                    };
                    falseValue: {
                        type: (NumberConstructor | StringConstructor)[];
                        default: undefined;
                    };
                    trueLabel: {
                        type: (NumberConstructor | StringConstructor)[];
                        default: undefined;
                    };
                    falseLabel: {
                        type: (NumberConstructor | StringConstructor)[];
                        default: undefined;
                    };
                    id: {
                        type: StringConstructor;
                        default: undefined;
                    };
                    border: BooleanConstructor;
                    size: {
                        readonly type: PropType<"" | "small" | "default" | "large">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    tabindex: (NumberConstructor | StringConstructor)[];
                    validateEvent: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>> & {
                    "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
                    onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
                }, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                    "update:modelValue": (val: import('element-plus').CheckboxValueType) => void;
                    change: (val: import('element-plus').CheckboxValueType) => void;
                }, string, {
                    label: string | number | boolean | Record<string, any>;
                    disabled: boolean;
                    border: boolean;
                    value: string | number | boolean | Record<string, any>;
                    id: string;
                    name: string;
                    modelValue: string | number | boolean;
                    validateEvent: boolean;
                    indeterminate: boolean;
                    checked: boolean;
                    trueValue: string | number;
                    falseValue: string | number;
                    trueLabel: string | number;
                    falseLabel: string | number;
                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
                    $slots: {
                        default?(_: {}): any;
                    };
                });
                CheckboxGroup: {
                    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                        readonly ariaLabel: StringConstructor;
                        readonly modelValue: {
                            readonly type: PropType<import('element-plus').CheckboxGroupValueType>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: () => never[];
                        };
                        readonly disabled: BooleanConstructor;
                        readonly min: NumberConstructor;
                        readonly max: NumberConstructor;
                        readonly size: {
                            readonly type: PropType<"" | "small" | "default" | "large">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly fill: StringConstructor;
                        readonly textColor: StringConstructor;
                        readonly tag: {
                            readonly type: PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "div";
                        };
                        readonly validateEvent: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: true;
                        };
                    }>> & {
                        "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxGroupValueType) => any) | undefined;
                        onChange?: ((val: import('element-plus').CheckboxValueType[]) => any) | undefined;
                    }, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                        "update:modelValue": (val: import('element-plus').CheckboxGroupValueType) => void;
                        change: (val: import('element-plus').CheckboxValueType[]) => void;
                    }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                        readonly disabled: boolean;
                        readonly modelValue: import('element-plus').CheckboxGroupValueType;
                        readonly validateEvent: boolean;
                        readonly tag: string;
                    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                        P: {};
                        B: {};
                        D: {};
                        C: {};
                        M: {};
                        Defaults: {};
                    }, Readonly<import('vue').ExtractPropTypes<{
                        readonly ariaLabel: StringConstructor;
                        readonly modelValue: {
                            readonly type: PropType<import('element-plus').CheckboxGroupValueType>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: () => never[];
                        };
                        readonly disabled: BooleanConstructor;
                        readonly min: NumberConstructor;
                        readonly max: NumberConstructor;
                        readonly size: {
                            readonly type: PropType<"" | "small" | "default" | "large">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly fill: StringConstructor;
                        readonly textColor: StringConstructor;
                        readonly tag: {
                            readonly type: PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "div";
                        };
                        readonly validateEvent: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: true;
                        };
                    }>> & {
                        "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxGroupValueType) => any) | undefined;
                        onChange?: ((val: import('element-plus').CheckboxValueType[]) => any) | undefined;
                    }, {}, {}, {}, {}, {
                        readonly disabled: boolean;
                        readonly modelValue: import('element-plus').CheckboxGroupValueType;
                        readonly validateEvent: boolean;
                        readonly tag: string;
                    }>;
                    __isFragment?: never;
                    __isTeleport?: never;
                    __isSuspense?: never;
                } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                    readonly ariaLabel: StringConstructor;
                    readonly modelValue: {
                        readonly type: PropType<import('element-plus').CheckboxGroupValueType>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => never[];
                    };
                    readonly disabled: BooleanConstructor;
                    readonly min: NumberConstructor;
                    readonly max: NumberConstructor;
                    readonly size: {
                        readonly type: PropType<"" | "small" | "default" | "large">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly fill: StringConstructor;
                    readonly textColor: StringConstructor;
                    readonly tag: {
                        readonly type: PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "div";
                    };
                    readonly validateEvent: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                }>> & {
                    "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxGroupValueType) => any) | undefined;
                    onChange?: ((val: import('element-plus').CheckboxValueType[]) => any) | undefined;
                }, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                    "update:modelValue": (val: import('element-plus').CheckboxGroupValueType) => void;
                    change: (val: import('element-plus').CheckboxValueType[]) => void;
                }, string, {
                    readonly disabled: boolean;
                    readonly modelValue: import('element-plus').CheckboxGroupValueType;
                    readonly validateEvent: boolean;
                    readonly tag: string;
                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
                    $slots: {
                        default?(_: {}): any;
                    };
                });
            };
        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        CellRender: typeof import('../util').CellRender;
    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
export default _default;