import { Ref, nextTick } from 'vue';
import { ElTableV2Instance, ElTableV2Props } from '../ele-app/el';
import { EleTooltipProps } from '../ele-app/plus';
import { DataKey, DataItem, Column, Filter, OrderValue } from '../ele-data-table/types';
import { BodyColumn, BodyColumns, HeaderRows, CellFilterChangeParams, SortBy, ScrollStrategy, ScrollPos, ColSize, VirtualRow } from './types';

declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
    rowHeight: NumberConstructor;
    stripe: {
        type: BooleanConstructor;
        default: null;
    };
    border: {
        type: BooleanConstructor;
        default: null;
    };
    rowKey: {
        type: import('vue').PropType<import('../ele-data-table/types').RowKey>;
        required: boolean;
    };
    columns: {
        type: import('vue').PropType<import('../ele-data-table/types').Columns>;
        required: boolean;
    };
    pageIndex: NumberConstructor;
    errorText: StringConstructor;
    headerEllipsis: {
        type: BooleanConstructor;
        default: boolean;
    };
    slotNormalize: {
        type: BooleanConstructor;
        default: boolean;
    };
    sticky: BooleanConstructor;
    bottomLine: {
        type: BooleanConstructor;
        default: boolean;
    };
    emptyProps: {
        type: import('vue').PropType<import('../ele-data-table/types').TableEmptyProps>;
        default: () => null;
    };
    rowClickChecked: import('vue').PropType<import('../ele-data-table/types').RowClickChecked>;
    reserveCurrent: BooleanConstructor;
    selectedRowKeys: import('vue').PropType<DataKey[]>;
    cacheData: import('vue').PropType<DataItem[]>;
    size: {
        readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    fit: {
        type: BooleanConstructor;
        default: boolean;
    };
    width: (NumberConstructor | StringConstructor)[];
    maxHeight: (NumberConstructor | StringConstructor)[];
    lazy: BooleanConstructor;
    className: {
        type: StringConstructor;
        default: string;
    };
    height: (NumberConstructor | StringConstructor)[];
    data: {
        type: import('vue').PropType<any[]>;
        default: () => never[];
    };
    showHeader: {
        type: BooleanConstructor;
        default: boolean;
    };
    showSummary: BooleanConstructor;
    sumText: StringConstructor;
    summaryMethod: import('vue').PropType<import('element-plus').SummaryMethod<any> | undefined>;
    rowClassName: import('vue').PropType<import('element-plus').ColumnCls<any> | undefined>;
    rowStyle: import('vue').PropType<import('element-plus').ColumnStyle<any> | undefined>;
    cellClassName: import('vue').PropType<import('element-plus').CellCls<any> | undefined>;
    cellStyle: import('vue').PropType<import('element-plus').CellStyle<any> | undefined>;
    headerRowClassName: import('vue').PropType<import('element-plus').ColumnCls<any> | undefined>;
    headerRowStyle: import('vue').PropType<import('element-plus').ColumnStyle<any> | undefined>;
    headerCellClassName: import('vue').PropType<import('element-plus').CellCls<any> | undefined>;
    headerCellStyle: import('vue').PropType<import('element-plus').CellStyle<any> | undefined>;
    highlightCurrentRow: BooleanConstructor;
    currentRowKey: (NumberConstructor | StringConstructor)[];
    emptyText: StringConstructor;
    expandRowKeys: import('vue').PropType<string[] | undefined>;
    defaultExpandAll: BooleanConstructor;
    defaultSort: import('vue').PropType<import('element-plus').Sort | undefined>;
    tooltipEffect: StringConstructor;
    tooltipOptions: import('vue').PropType<Partial<Pick<import('element-plus').ElTooltipProps, "offset" | "transition" | "placement" | "effect" | "showAfter" | "hideAfter" | "popperOptions" | "enterable" | "popperClass" | "appendTo" | "showArrow">> | undefined>;
    spanMethod: import('vue').PropType<((data: {
        row: any;
        rowIndex: number;
        column: import('element-plus').TableColumnCtx<any>;
        columnIndex: number;
    }) => number[] | {
        rowspan: number;
        colspan: number;
    } | undefined) | undefined>;
    selectOnIndeterminate: {
        type: BooleanConstructor;
        default: boolean;
    };
    indent: {
        type: NumberConstructor;
        default: number;
    };
    treeProps: {
        type: import('vue').PropType<import('element-plus/es/components/table/src/table/defaults').TreeProps | undefined>;
        default: () => {
            hasChildren: string;
            children: string;
            checkStrictly: boolean;
        };
    };
    load: import('vue').PropType<((row: any, treeNode: import('element-plus').TreeNode, resolve: (data: any[]) => void) => void) | undefined>;
    tableLayout: {
        type: import('vue').PropType<"fixed" | "auto">;
        default: string;
    };
    scrollbarAlwaysOn: BooleanConstructor;
    flexible: BooleanConstructor;
    showOverflowTooltip: import('vue').PropType<boolean | Partial<Pick<import('element-plus').ElTooltipProps, "offset" | "transition" | "placement" | "effect" | "showAfter" | "hideAfter" | "popperOptions" | "enterable" | "popperClass" | "appendTo" | "showArrow">> | undefined>;
    appendFilterPanelTo: StringConstructor;
    scrollbarTabindex: {
        type: (NumberConstructor | StringConstructor)[];
        default: undefined;
    };
}>, {
    ownSlots: string[];
    rootRef: Ref<HTMLElement | null, HTMLElement | null>;
    tableRef: Ref<ElTableV2Instance, ElTableV2Instance>;
    tableKey: Ref<number, number>;
    wrapWidth: Ref<number, number>;
    headerRows: Ref<HeaderRows, HeaderRows>;
    bodyCols: Ref<BodyColumns, BodyColumns>;
    headerRowSizes: Ref<ColSize[][], ColSize[][]>;
    bodyColSizes: Ref<ColSize[], ColSize[]>;
    colsSumWidth: Ref<number, number>;
    tableWidth: Ref<number, number>;
    tableData: Ref<VirtualRow[], VirtualRow[]>;
    isCheckAll: Ref<boolean, boolean>;
    isIndeterminate: import('vue').ComputedRef<boolean>;
    checkedRowKeys: Ref<Set<DataKey>, Set<DataKey>>;
    expandedRowKeys: Ref<DataKey[], DataKey[]>;
    sortBy: Ref<SortBy | undefined, SortBy | undefined>;
    filtered: Filter;
    tableTooltipProps: Partial<import('../ele-tooltip/props').TooltipProps>;
    tableExpandCol: import('vue').ComputedRef<BodyColumn | undefined>;
    hasExpandCol: import('vue').ComputedRef<boolean>;
    tableExpandColumnKey: import('vue').ComputedRef<string | undefined>;
    tableRowHeight: import('vue').ComputedRef<number>;
    autoRowHeight: import('vue').ComputedRef<boolean>;
    hasFooter: import('vue').ComputedRef<boolean>;
    tableProps: import('vue').ComputedRef<Required<ElTableV2Props>>;
    isPingLeft: import('vue').ComputedRef<boolean>;
    isPingRight: import('vue').ComputedRef<boolean>;
    tableSumText: import('vue').ComputedRef<string>;
    tableEmptyText: import('vue').ComputedRef<string>;
    isLayoutFixedHead: import('vue').ComputedRef<boolean | undefined>;
    isLayoutMaximized: import('vue').ComputedRef<boolean | undefined>;
    handleTableFilterChange: (params: CellFilterChangeParams) => void;
    handleCellCheckedChange: (row: VirtualRow, checked: boolean) => void;
    handleCellExpandChange: (row: VirtualRow, expanded: boolean, children?: DataItem[]) => void;
    handleCellClick: (row: VirtualRow, col: Column, e: MouseEvent) => void;
    handleCellDblclick: (row: VirtualRow, col: Column, e: MouseEvent) => void;
    handleCellContextmenu: (row: VirtualRow, col: Column, e: MouseEvent) => void;
    handleCellMouseenter: (row: VirtualRow, col: Column, e: MouseEvent) => void;
    handleCellMouseleave: (row: VirtualRow, col: Column, e: MouseEvent) => void;
    handleHeaderCellClick: (col: Column | undefined, e: MouseEvent) => void;
    handleHeaderCellContextmenu: (col: Column, e: MouseEvent) => void;
    handleHeaderCellMouseenter: () => void;
    handleFooterCellMouseenter: (e: MouseEvent) => void;
    handleExpandCellMouseenter: () => void;
    handleTableMouseleave: () => void;
    handleTableScroll: (option: ScrollPos) => void;
    updateWrapSize: () => void;
    updateTableData: () => void;
    updateSelectedAndChecked: () => void;
    setSelectedRows: (rows?: DataItem[]) => void;
    setSelectedRowKeys: (keys?: DataKey[]) => void;
    toggleRowExpansionAll: (expanded?: boolean) => void;
    clearSelection: () => void;
    getSelectionRows: () => DataItem[];
    toggleRowSelection: (row: DataItem, selected?: boolean) => void;
    toggleAllSelection: () => void;
    toggleRowExpansion: (row: VirtualRow, expanded?: boolean) => void;
    setCurrentRow: (row?: DataItem | null) => void;
    setCurrentRowKey: (key?: DataKey | null) => void;
    getCurrentRow: () => DataItem | undefined;
    clearSort: () => void;
    clearFilter: (columnKeys?: string[]) => void;
    doLayout: (force?: boolean) => void;
    sort: (prop: string, order: OrderValue) => void;
    scrollTo: (options: number | ScrollToOptions, yCoord?: number) => void;
    setScrollTop: (top?: number) => void;
    setScrollLeft: (left?: number) => void;
    scrollToRow: (row: number, strategy: ScrollStrategy) => void;
    hideTooltip: () => void;
}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
    select: (_selection: DataItem[], _row: DataItem) => boolean;
    selectAll: (_selection: DataItem[]) => boolean;
    selectionChange: (_selection: DataItem[]) => boolean;
    cellMouseEnter: (_row: DataItem, _column: Column, _cell: HTMLTableCellElement, _e: MouseEvent) => boolean;
    cellMouseLeave: (_row: DataItem, _column: Column, _cell: HTMLTableCellElement, _e: MouseEvent) => boolean;
    cellClick: (_row: DataItem, _column: Column, _cell: HTMLTableCellElement, _e: MouseEvent) => boolean;
    cellDblclick: (_row: DataItem, _column: Column, _cell: HTMLTableCellElement, _e: MouseEvent) => boolean;
    cellContextmenu: (_row: DataItem, _column: Column, _cell: HTMLTableCellElement, _e: MouseEvent) => boolean;
    rowClick: (_row: DataItem, _column: Column, _e: MouseEvent) => boolean;
    rowContextmenu: (_row: DataItem, _column: Column, _e: MouseEvent) => boolean;
    rowDblclick: (_row: DataItem, _column: Column, _e: MouseEvent) => boolean;
    headerClick: (_column: Column, _e: MouseEvent) => boolean;
    headerContextmenu: (_column: Column, _e: MouseEvent) => boolean;
    sortChange: (_sorter: import('../ele-data-table/types').Sorter) => boolean;
    filterChange: (_filter: Filter) => boolean;
    currentChange: (_current?: DataItem | null, _old?: DataItem | null) => boolean;
    headerDragend: (_width: number, _old: number, _column: Column, _e: MouseEvent) => boolean;
    expandChange: (_row: DataItem, _expanded: boolean) => boolean;
    'update:currentRowKey': (_currentRowKey?: DataKey) => boolean;
    'update:selectedRowKeys': (_selectedRowKeys?: DataKey[]) => boolean;
}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
    rowHeight: NumberConstructor;
    stripe: {
        type: BooleanConstructor;
        default: null;
    };
    border: {
        type: BooleanConstructor;
        default: null;
    };
    rowKey: {
        type: import('vue').PropType<import('../ele-data-table/types').RowKey>;
        required: boolean;
    };
    columns: {
        type: import('vue').PropType<import('../ele-data-table/types').Columns>;
        required: boolean;
    };
    pageIndex: NumberConstructor;
    errorText: StringConstructor;
    headerEllipsis: {
        type: BooleanConstructor;
        default: boolean;
    };
    slotNormalize: {
        type: BooleanConstructor;
        default: boolean;
    };
    sticky: BooleanConstructor;
    bottomLine: {
        type: BooleanConstructor;
        default: boolean;
    };
    emptyProps: {
        type: import('vue').PropType<import('../ele-data-table/types').TableEmptyProps>;
        default: () => null;
    };
    rowClickChecked: import('vue').PropType<import('../ele-data-table/types').RowClickChecked>;
    reserveCurrent: BooleanConstructor;
    selectedRowKeys: import('vue').PropType<DataKey[]>;
    cacheData: import('vue').PropType<DataItem[]>;
    size: {
        readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    fit: {
        type: BooleanConstructor;
        default: boolean;
    };
    width: (NumberConstructor | StringConstructor)[];
    maxHeight: (NumberConstructor | StringConstructor)[];
    lazy: BooleanConstructor;
    className: {
        type: StringConstructor;
        default: string;
    };
    height: (NumberConstructor | StringConstructor)[];
    data: {
        type: import('vue').PropType<any[]>;
        default: () => never[];
    };
    showHeader: {
        type: BooleanConstructor;
        default: boolean;
    };
    showSummary: BooleanConstructor;
    sumText: StringConstructor;
    summaryMethod: import('vue').PropType<import('element-plus').SummaryMethod<any> | undefined>;
    rowClassName: import('vue').PropType<import('element-plus').ColumnCls<any> | undefined>;
    rowStyle: import('vue').PropType<import('element-plus').ColumnStyle<any> | undefined>;
    cellClassName: import('vue').PropType<import('element-plus').CellCls<any> | undefined>;
    cellStyle: import('vue').PropType<import('element-plus').CellStyle<any> | undefined>;
    headerRowClassName: import('vue').PropType<import('element-plus').ColumnCls<any> | undefined>;
    headerRowStyle: import('vue').PropType<import('element-plus').ColumnStyle<any> | undefined>;
    headerCellClassName: import('vue').PropType<import('element-plus').CellCls<any> | undefined>;
    headerCellStyle: import('vue').PropType<import('element-plus').CellStyle<any> | undefined>;
    highlightCurrentRow: BooleanConstructor;
    currentRowKey: (NumberConstructor | StringConstructor)[];
    emptyText: StringConstructor;
    expandRowKeys: import('vue').PropType<string[] | undefined>;
    defaultExpandAll: BooleanConstructor;
    defaultSort: import('vue').PropType<import('element-plus').Sort | undefined>;
    tooltipEffect: StringConstructor;
    tooltipOptions: import('vue').PropType<Partial<Pick<import('element-plus').ElTooltipProps, "offset" | "transition" | "placement" | "effect" | "showAfter" | "hideAfter" | "popperOptions" | "enterable" | "popperClass" | "appendTo" | "showArrow">> | undefined>;
    spanMethod: import('vue').PropType<((data: {
        row: any;
        rowIndex: number;
        column: import('element-plus').TableColumnCtx<any>;
        columnIndex: number;
    }) => number[] | {
        rowspan: number;
        colspan: number;
    } | undefined) | undefined>;
    selectOnIndeterminate: {
        type: BooleanConstructor;
        default: boolean;
    };
    indent: {
        type: NumberConstructor;
        default: number;
    };
    treeProps: {
        type: import('vue').PropType<import('element-plus/es/components/table/src/table/defaults').TreeProps | undefined>;
        default: () => {
            hasChildren: string;
            children: string;
            checkStrictly: boolean;
        };
    };
    load: import('vue').PropType<((row: any, treeNode: import('element-plus').TreeNode, resolve: (data: any[]) => void) => void) | undefined>;
    tableLayout: {
        type: import('vue').PropType<"fixed" | "auto">;
        default: string;
    };
    scrollbarAlwaysOn: BooleanConstructor;
    flexible: BooleanConstructor;
    showOverflowTooltip: import('vue').PropType<boolean | Partial<Pick<import('element-plus').ElTooltipProps, "offset" | "transition" | "placement" | "effect" | "showAfter" | "hideAfter" | "popperOptions" | "enterable" | "popperClass" | "appendTo" | "showArrow">> | undefined>;
    appendFilterPanelTo: StringConstructor;
    scrollbarTabindex: {
        type: (NumberConstructor | StringConstructor)[];
        default: undefined;
    };
}>> & Readonly<{
    onSelect?: ((_selection: DataItem[], _row: DataItem) => any) | undefined;
    onFilterChange?: ((_filter: Filter) => any) | undefined;
    onSelectAll?: ((_selection: DataItem[]) => any) | undefined;
    onSelectionChange?: ((_selection: DataItem[]) => any) | undefined;
    onCellMouseEnter?: ((_row: DataItem, _column: Column, _cell: HTMLTableCellElement, _e: MouseEvent) => any) | undefined;
    onCellMouseLeave?: ((_row: DataItem, _column: Column, _cell: HTMLTableCellElement, _e: MouseEvent) => any) | undefined;
    onCellClick?: ((_row: DataItem, _column: Column, _cell: HTMLTableCellElement, _e: MouseEvent) => any) | undefined;
    onCellDblclick?: ((_row: DataItem, _column: Column, _cell: HTMLTableCellElement, _e: MouseEvent) => any) | undefined;
    onCellContextmenu?: ((_row: DataItem, _column: Column, _cell: HTMLTableCellElement, _e: MouseEvent) => any) | undefined;
    onRowClick?: ((_row: DataItem, _column: Column, _e: MouseEvent) => any) | undefined;
    onRowContextmenu?: ((_row: DataItem, _column: Column, _e: MouseEvent) => any) | undefined;
    onRowDblclick?: ((_row: DataItem, _column: Column, _e: MouseEvent) => any) | undefined;
    onHeaderClick?: ((_column: Column, _e: MouseEvent) => any) | undefined;
    onHeaderContextmenu?: ((_column: Column, _e: MouseEvent) => any) | undefined;
    onSortChange?: ((_sorter: import('../ele-data-table/types').Sorter) => any) | undefined;
    onCurrentChange?: ((_current?: DataItem | null | undefined, _old?: DataItem | null | undefined) => any) | undefined;
    onHeaderDragend?: ((_width: number, _old: number, _column: Column, _e: MouseEvent) => any) | undefined;
    onExpandChange?: ((_row: DataItem, _expanded: boolean) => any) | undefined;
    "onUpdate:currentRowKey"?: ((_currentRowKey?: DataKey | undefined) => any) | undefined;
    "onUpdate:selectedRowKeys"?: ((_selectedRowKeys?: DataKey[] | undefined) => any) | undefined;
}>, {
    fit: boolean;
    lazy: boolean;
    className: string;
    data: any[];
    stripe: boolean;
    border: boolean;
    showHeader: boolean;
    showSummary: boolean;
    highlightCurrentRow: boolean;
    defaultExpandAll: boolean;
    selectOnIndeterminate: boolean;
    indent: number;
    treeProps: import('element-plus/es/components/table/src/table/defaults').TreeProps | undefined;
    tableLayout: "fixed" | "auto";
    scrollbarAlwaysOn: boolean;
    flexible: boolean;
    scrollbarTabindex: string | number;
    sticky: boolean;
    headerEllipsis: boolean;
    slotNormalize: boolean;
    bottomLine: boolean;
    emptyProps: import('../ele-data-table/types').TableEmptyProps;
    reserveCurrent: boolean;
}, {}, {
    ElTableV2: import('element-plus/es/utils/index').SFCWithInstall<import('vue').DefineComponent<{
        readonly cache: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, never, never, 2, false>;
        readonly estimatedRowHeight: {
            readonly default: undefined;
            readonly type: import('vue').PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            readonly __epPropKey: true;
        };
        readonly rowKey: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus/es/components/table-v2/src/types').KeyType & {}) | (() => import('element-plus/es/components/table-v2/src/types').KeyType) | ((new (...args: any[]) => import('element-plus/es/components/table-v2/src/types').KeyType & {}) | (() => import('element-plus/es/components/table-v2/src/types').KeyType))[], unknown, unknown, "id", boolean>;
        readonly headerClass: {
            readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | import('element-plus').HeaderClassNameGetter<any>) & {}) | (() => string | import('element-plus').HeaderClassNameGetter<any>) | ((new (...args: any[]) => (string | import('element-plus').HeaderClassNameGetter<any>) & {}) | (() => string | import('element-plus').HeaderClassNameGetter<any>))[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly headerProps: {
            readonly type: import('vue').PropType<any>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly headerCellProps: {
            readonly type: import('vue').PropType<any>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly headerHeight: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => (number | number[]) & {}) | (() => number | number[]) | ((new (...args: any[]) => (number | number[]) & {}) | (() => number | number[]))[], unknown, unknown, 50, boolean>;
        readonly footerHeight: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
        readonly rowClass: {
            readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | import('element-plus').RowClassNameGetter<any>) & {}) | (() => string | import('element-plus').RowClassNameGetter<any>) | ((new (...args: any[]) => (string | import('element-plus').RowClassNameGetter<any>) & {}) | (() => string | import('element-plus').RowClassNameGetter<any>))[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly rowProps: {
            readonly type: import('vue').PropType<any>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly rowHeight: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 50, boolean>;
        readonly cellProps: {
            readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => Record<string, any> | import('element-plus').ExtraCellPropGetter<any>) | (() => Record<string, any> | import('element-plus').ExtraCellPropGetter<any>) | ((new (...args: any[]) => Record<string, any> | import('element-plus').ExtraCellPropGetter<any>) | (() => Record<string, any> | import('element-plus').ExtraCellPropGetter<any>))[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly columns: {
            readonly type: import('vue').PropType<import('element-plus/es/components/table-v2/src/common').AnyColumn[]>;
            readonly required: true;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly data: {
            readonly type: import('vue').PropType<any[]>;
            readonly required: true;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly dataGetter: {
            readonly type: import('vue').PropType<import('element-plus/es/components/table-v2/src/types').DataGetter<any>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly fixedData: {
            readonly type: import('vue').PropType<any[]>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly expandColumnKey: StringConstructor;
        readonly expandedRowKeys: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus/es/components/table-v2/src/types').KeyType[]) | (() => import('element-plus/es/components/table-v2/src/types').KeyType[]) | ((new (...args: any[]) => import('element-plus/es/components/table-v2/src/types').KeyType[]) | (() => import('element-plus/es/components/table-v2/src/types').KeyType[]))[], unknown, unknown, () => never[], boolean>;
        readonly defaultExpandedRowKeys: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus/es/components/table-v2/src/types').KeyType[]) | (() => import('element-plus/es/components/table-v2/src/types').KeyType[]) | ((new (...args: any[]) => import('element-plus/es/components/table-v2/src/types').KeyType[]) | (() => import('element-plus/es/components/table-v2/src/types').KeyType[]))[], unknown, unknown, () => never[], boolean>;
        readonly class: StringConstructor;
        readonly fixed: BooleanConstructor;
        readonly style: {
            readonly type: import('vue').PropType<import('vue').CSSProperties>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly width: {
            readonly type: import('vue').PropType<number>;
            readonly required: true;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly height: {
            readonly type: import('vue').PropType<number>;
            readonly required: true;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly maxHeight: NumberConstructor;
        readonly useIsScrolling: BooleanConstructor;
        readonly indentSize: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 12, boolean>;
        readonly iconSize: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 12, boolean>;
        readonly hScrollbarSize: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 6, boolean>;
        readonly vScrollbarSize: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 6, boolean>;
        readonly scrollbarAlwaysOn: BooleanConstructor;
        readonly sortBy: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus/es/components/table-v2/src/types').SortBy) | (() => import('element-plus/es/components/table-v2/src/types').SortBy) | ((new (...args: any[]) => import('element-plus/es/components/table-v2/src/types').SortBy) | (() => import('element-plus/es/components/table-v2/src/types').SortBy))[], unknown, unknown, () => {
            key: import('element-plus/es/components/table-v2/src/types').KeyType;
            order: import('element-plus').SortOrder;
        }, boolean>;
        readonly sortState: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').SortState) | (() => import('element-plus').SortState) | ((new (...args: any[]) => import('element-plus').SortState) | (() => import('element-plus').SortState))[], unknown, unknown, undefined, boolean>;
        readonly onColumnSort: {
            readonly type: import('vue').PropType<import('element-plus').ColumnSortHandler<any>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly onExpandedRowsChange: {
            readonly type: import('vue').PropType<import('element-plus').ExpandedRowsChangeHandler>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly onEndReached: {
            readonly type: import('vue').PropType<(distance: number) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly onRowExpand: {
            readonly type: import('vue').PropType<import('element-plus').RowExpandHandler>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly onScroll: {
            readonly type: import('vue').PropType<(...args: any[]) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly onRowsRendered: {
            readonly type: import('vue').PropType<(params: import('element-plus/es/components/table-v2/src/grid').onRowRenderedParams) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly rowEventHandlers: {
            readonly type: import('vue').PropType<import('element-plus').RowEventHandlers>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
    }, () => JSX.Element, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, Readonly<import('vue').ExtractPropTypes<{
        readonly cache: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, never, never, 2, false>;
        readonly estimatedRowHeight: {
            readonly default: undefined;
            readonly type: import('vue').PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            readonly __epPropKey: true;
        };
        readonly rowKey: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus/es/components/table-v2/src/types').KeyType & {}) | (() => import('element-plus/es/components/table-v2/src/types').KeyType) | ((new (...args: any[]) => import('element-plus/es/components/table-v2/src/types').KeyType & {}) | (() => import('element-plus/es/components/table-v2/src/types').KeyType))[], unknown, unknown, "id", boolean>;
        readonly headerClass: {
            readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | import('element-plus').HeaderClassNameGetter<any>) & {}) | (() => string | import('element-plus').HeaderClassNameGetter<any>) | ((new (...args: any[]) => (string | import('element-plus').HeaderClassNameGetter<any>) & {}) | (() => string | import('element-plus').HeaderClassNameGetter<any>))[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly headerProps: {
            readonly type: import('vue').PropType<any>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly headerCellProps: {
            readonly type: import('vue').PropType<any>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly headerHeight: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => (number | number[]) & {}) | (() => number | number[]) | ((new (...args: any[]) => (number | number[]) & {}) | (() => number | number[]))[], unknown, unknown, 50, boolean>;
        readonly footerHeight: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
        readonly rowClass: {
            readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | import('element-plus').RowClassNameGetter<any>) & {}) | (() => string | import('element-plus').RowClassNameGetter<any>) | ((new (...args: any[]) => (string | import('element-plus').RowClassNameGetter<any>) & {}) | (() => string | import('element-plus').RowClassNameGetter<any>))[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly rowProps: {
            readonly type: import('vue').PropType<any>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly rowHeight: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 50, boolean>;
        readonly cellProps: {
            readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => Record<string, any> | import('element-plus').ExtraCellPropGetter<any>) | (() => Record<string, any> | import('element-plus').ExtraCellPropGetter<any>) | ((new (...args: any[]) => Record<string, any> | import('element-plus').ExtraCellPropGetter<any>) | (() => Record<string, any> | import('element-plus').ExtraCellPropGetter<any>))[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly columns: {
            readonly type: import('vue').PropType<import('element-plus/es/components/table-v2/src/common').AnyColumn[]>;
            readonly required: true;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly data: {
            readonly type: import('vue').PropType<any[]>;
            readonly required: true;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly dataGetter: {
            readonly type: import('vue').PropType<import('element-plus/es/components/table-v2/src/types').DataGetter<any>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly fixedData: {
            readonly type: import('vue').PropType<any[]>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly expandColumnKey: StringConstructor;
        readonly expandedRowKeys: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus/es/components/table-v2/src/types').KeyType[]) | (() => import('element-plus/es/components/table-v2/src/types').KeyType[]) | ((new (...args: any[]) => import('element-plus/es/components/table-v2/src/types').KeyType[]) | (() => import('element-plus/es/components/table-v2/src/types').KeyType[]))[], unknown, unknown, () => never[], boolean>;
        readonly defaultExpandedRowKeys: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus/es/components/table-v2/src/types').KeyType[]) | (() => import('element-plus/es/components/table-v2/src/types').KeyType[]) | ((new (...args: any[]) => import('element-plus/es/components/table-v2/src/types').KeyType[]) | (() => import('element-plus/es/components/table-v2/src/types').KeyType[]))[], unknown, unknown, () => never[], boolean>;
        readonly class: StringConstructor;
        readonly fixed: BooleanConstructor;
        readonly style: {
            readonly type: import('vue').PropType<import('vue').CSSProperties>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly width: {
            readonly type: import('vue').PropType<number>;
            readonly required: true;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly height: {
            readonly type: import('vue').PropType<number>;
            readonly required: true;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly maxHeight: NumberConstructor;
        readonly useIsScrolling: BooleanConstructor;
        readonly indentSize: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 12, boolean>;
        readonly iconSize: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 12, boolean>;
        readonly hScrollbarSize: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 6, boolean>;
        readonly vScrollbarSize: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 6, boolean>;
        readonly scrollbarAlwaysOn: BooleanConstructor;
        readonly sortBy: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus/es/components/table-v2/src/types').SortBy) | (() => import('element-plus/es/components/table-v2/src/types').SortBy) | ((new (...args: any[]) => import('element-plus/es/components/table-v2/src/types').SortBy) | (() => import('element-plus/es/components/table-v2/src/types').SortBy))[], unknown, unknown, () => {
            key: import('element-plus/es/components/table-v2/src/types').KeyType;
            order: import('element-plus').SortOrder;
        }, boolean>;
        readonly sortState: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').SortState) | (() => import('element-plus').SortState) | ((new (...args: any[]) => import('element-plus').SortState) | (() => import('element-plus').SortState))[], unknown, unknown, undefined, boolean>;
        readonly onColumnSort: {
            readonly type: import('vue').PropType<import('element-plus').ColumnSortHandler<any>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly onExpandedRowsChange: {
            readonly type: import('vue').PropType<import('element-plus').ExpandedRowsChangeHandler>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly onEndReached: {
            readonly type: import('vue').PropType<(distance: number) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly onRowExpand: {
            readonly type: import('vue').PropType<import('element-plus').RowExpandHandler>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly onScroll: {
            readonly type: import('vue').PropType<(...args: any[]) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly onRowsRendered: {
            readonly type: import('vue').PropType<(params: import('element-plus/es/components/table-v2/src/grid').onRowRenderedParams) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly rowEventHandlers: {
            readonly type: import('vue').PropType<import('element-plus').RowEventHandlers>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
    }>>, {
        readonly fixed: boolean;
        readonly rowKey: import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => import('element-plus/es/components/table-v2/src/types').KeyType & {}) | (() => import('element-plus/es/components/table-v2/src/types').KeyType) | ((new (...args: any[]) => import('element-plus/es/components/table-v2/src/types').KeyType & {}) | (() => import('element-plus/es/components/table-v2/src/types').KeyType))[], unknown, unknown>;
        readonly scrollbarAlwaysOn: boolean;
        readonly useIsScrolling: boolean;
        readonly cache: number;
        readonly estimatedRowHeight: number;
        readonly rowHeight: number;
        readonly hScrollbarSize: number;
        readonly vScrollbarSize: number;
        readonly sortBy: import('element-plus/es/components/table-v2/src/types').SortBy;
        readonly headerHeight: import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (number | number[]) & {}) | (() => number | number[]) | ((new (...args: any[]) => (number | number[]) & {}) | (() => number | number[]))[], unknown, unknown>;
        readonly footerHeight: number;
        readonly indentSize: number;
        readonly iconSize: number;
        readonly sortState: import('element-plus').SortState;
        readonly expandedRowKeys: import('element-plus/es/components/table-v2/src/types').KeyType[];
        readonly defaultExpandedRowKeys: import('element-plus/es/components/table-v2/src/types').KeyType[];
    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>>;
    ElEmpty: import('element-plus/es/utils/index').SFCWithInstall<{
        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
            readonly image: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
            readonly imageSize: NumberConstructor;
            readonly description: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
        }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
            readonly image: string;
            readonly description: string;
        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import('vue').ExtractPropTypes<{
            readonly image: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
            readonly imageSize: NumberConstructor;
            readonly description: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
        }>>, {}, {}, {}, {}, {
            readonly image: string;
            readonly description: string;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
        readonly image: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
        readonly imageSize: NumberConstructor;
        readonly description: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
        readonly image: string;
        readonly description: string;
    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
        $slots: {
            image?(_: {}): any;
            description?(_: {}): any;
            default?(_: {}): any;
        };
    })>;
    EleTooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        bodyStyle: import('vue').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').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').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: import('vue').PropType<import('../ele-app/types').StyleValue>;
    }>, {
        tooltipRef: 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: import('vue').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').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').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: import('vue').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').PropType<import('element-plus').Measurable>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                virtualTriggering: BooleanConstructor;
                onMouseenter: {
                    readonly type: import('vue').PropType<(e: Event) => void>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                onMouseleave: {
                    readonly type: import('vue').PropType<(e: Event) => void>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                onClick: {
                    readonly type: import('vue').PropType<(e: Event) => void>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                onKeydown: {
                    readonly type: import('vue').PropType<(e: Event) => void>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                onFocus: {
                    readonly type: import('vue').PropType<(e: Event) => void>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                onBlur: {
                    readonly type: import('vue').PropType<(e: Event) => void>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                onContextmenu: {
                    readonly type: import('vue').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').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').PropType<import('vue').StyleValue>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                className: {
                    readonly type: import('vue').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').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').PropType<import('vue').StyleValue>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                referenceEl: {
                    readonly type: import('vue').PropType<HTMLElement>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                triggerTargetEl: {
                    readonly type: import('vue').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').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/dist/vue.js').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/dist/vue.js').Ref<import('element-plus').Measurable | undefined>;
                        contentRef: import('vue/dist/vue.js').Ref<HTMLElement | undefined>;
                        popperInstanceRef: import('vue/dist/vue.js').Ref<import('@popperjs/core').Instance | undefined>;
                        referenceRef: import('vue/dist/vue.js').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/dist/vue.js').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/dist/vue.js').Ref<import('element-plus').Measurable | undefined>;
                    contentRef: import('vue/dist/vue.js').Ref<HTMLElement | undefined>;
                    popperInstanceRef: import('vue/dist/vue.js').Ref<import('@popperjs/core').Instance | undefined>;
                    referenceRef: import('vue/dist/vue.js').Ref<import('element-plus').Measurable | undefined>;
                    role: import('vue').ComputedRef<string>;
                }> & {} & import('vue').ComponentCustomProperties & {
                    $slots: {
                        default?(_: {}): any;
                    };
                }) | undefined>;
                contentRef: import('vue/dist/vue.js').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').PropType<import('element-plus').Measurable>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                virtualTriggering: BooleanConstructor;
                onMouseenter: {
                    readonly type: import('vue').PropType<(e: Event) => void>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                onMouseleave: {
                    readonly type: import('vue').PropType<(e: Event) => void>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                onClick: {
                    readonly type: import('vue').PropType<(e: Event) => void>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                onKeydown: {
                    readonly type: import('vue').PropType<(e: Event) => void>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                onFocus: {
                    readonly type: import('vue').PropType<(e: Event) => void>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                onBlur: {
                    readonly type: import('vue').PropType<(e: Event) => void>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                onContextmenu: {
                    readonly type: import('vue').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').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').PropType<import('vue').StyleValue>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                className: {
                    readonly type: import('vue').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').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').PropType<import('vue').StyleValue>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                referenceEl: {
                    readonly type: import('vue').PropType<HTMLElement>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                triggerTargetEl: {
                    readonly type: import('vue').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').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/dist/vue.js').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/dist/vue.js').Ref<import('element-plus').Measurable | undefined>;
                        contentRef: import('vue/dist/vue.js').Ref<HTMLElement | undefined>;
                        popperInstanceRef: import('vue/dist/vue.js').Ref<import('@popperjs/core').Instance | undefined>;
                        referenceRef: import('vue/dist/vue.js').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/dist/vue.js').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/dist/vue.js').Ref<import('element-plus').Measurable | undefined>;
                    contentRef: import('vue/dist/vue.js').Ref<HTMLElement | undefined>;
                    popperInstanceRef: import('vue/dist/vue.js').Ref<import('@popperjs/core').Instance | undefined>;
                    referenceRef: import('vue/dist/vue.js').Ref<import('element-plus').Measurable | undefined>;
                    role: import('vue').ComputedRef<string>;
                }> & {} & import('vue').ComponentCustomProperties & {
                    $slots: {
                        default?(_: {}): any;
                    };
                }) | undefined>;
                contentRef: import('vue/dist/vue.js').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').PropType<import('element-plus').Measurable>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            virtualTriggering: BooleanConstructor;
            onMouseenter: {
                readonly type: import('vue').PropType<(e: Event) => void>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            onMouseleave: {
                readonly type: import('vue').PropType<(e: Event) => void>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            onClick: {
                readonly type: import('vue').PropType<(e: Event) => void>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            onKeydown: {
                readonly type: import('vue').PropType<(e: Event) => void>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            onFocus: {
                readonly type: import('vue').PropType<(e: Event) => void>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            onBlur: {
                readonly type: import('vue').PropType<(e: Event) => void>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            onContextmenu: {
                readonly type: import('vue').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').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').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').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').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').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').PropType<HTMLElement>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            triggerTargetEl: {
                readonly type: import('vue').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').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/dist/vue.js').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/dist/vue.js').Ref<import('element-plus').Measurable | undefined>;
                    contentRef: import('vue/dist/vue.js').Ref<HTMLElement | undefined>;
                    popperInstanceRef: import('vue/dist/vue.js').Ref<import('@popperjs/core').Instance | undefined>;
                    referenceRef: import('vue/dist/vue.js').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/dist/vue.js').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/dist/vue.js').Ref<import('element-plus').Measurable | undefined>;
                contentRef: import('vue/dist/vue.js').Ref<HTMLElement | undefined>;
                popperInstanceRef: import('vue/dist/vue.js').Ref<import('@popperjs/core').Instance | undefined>;
                referenceRef: import('vue/dist/vue.js').Ref<import('element-plus').Measurable | undefined>;
                role: import('vue').ComputedRef<string>;
            }> & {} & import('vue').ComponentCustomProperties & {
                $slots: {
                    default?(_: {}): any;
                };
            }) | undefined>;
            contentRef: import('vue/dist/vue.js').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>;
    HeaderRow: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        headerCols: import('vue').PropType<import('./types').HeaderColumns>;
        headerColSizes: import('vue').PropType<ColSize[]>;
        headerIndex: NumberConstructor;
        sortBy: import('vue').PropType<SortBy>;
        filtered: import('vue').PropType<Filter>;
        isCheckAll: BooleanConstructor;
        isIndeterminate: BooleanConstructor;
        disabledCheckbox: BooleanConstructor;
        tableSize: import('vue').PropType<import('../ele-data-table/types').TableSize>;
        headerCellClass: import('vue').PropType<import('../ele-data-table/types').HeaderCellClass>;
        headerCellStyle: import('vue').PropType<import('../ele-data-table/types').HeaderCellStyle>;
        headerEllipsis: BooleanConstructor;
        rowHeight: NumberConstructor;
    }>, {
        getKey: (column: import('./types').VirtualColumn, columnIndex: number) => string;
        getFiltered: (column: import('./types').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: import('vue').PropType<import('./types').HeaderColumns>;
        headerColSizes: import('vue').PropType<ColSize[]>;
        headerIndex: NumberConstructor;
        sortBy: import('vue').PropType<SortBy>;
        filtered: import('vue').PropType<Filter>;
        isCheckAll: BooleanConstructor;
        isIndeterminate: BooleanConstructor;
        disabledCheckbox: BooleanConstructor;
        tableSize: import('vue').PropType<import('../ele-data-table/types').TableSize>;
        headerCellClass: import('vue').PropType<import('../ele-data-table/types').HeaderCellClass>;
        headerCellStyle: import('vue').PropType<import('../ele-data-table/types').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: import('vue').PropType<import('./types').HeaderColumn>;
            columnIndex: NumberConstructor;
            headerIndex: NumberConstructor;
            colSize: import('vue').PropType<ColSize>;
            sortBy: import('vue').PropType<SortBy>;
            filterValue: import('vue').PropType<import('../ele-data-table/types').FilterValue>;
            isCheckAll: BooleanConstructor;
            isIndeterminate: BooleanConstructor;
            disabledCheckbox: BooleanConstructor;
            tableSize: import('vue').PropType<import('../ele-data-table/types').TableSize>;
            headerCellClass: import('vue').PropType<import('../ele-data-table/types').HeaderCellClass>;
            headerCellStyle: import('vue').PropType<import('../ele-data-table/types').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: import('vue').PropType<import('./types').HeaderColumn>;
            columnIndex: NumberConstructor;
            headerIndex: NumberConstructor;
            colSize: import('vue').PropType<ColSize>;
            sortBy: import('vue').PropType<SortBy>;
            filterValue: import('vue').PropType<import('../ele-data-table/types').FilterValue>;
            isCheckAll: BooleanConstructor;
            isIndeterminate: BooleanConstructor;
            disabledCheckbox: BooleanConstructor;
            tableSize: import('vue').PropType<import('../ele-data-table/types').TableSize>;
            headerCellClass: import('vue').PropType<import('../ele-data-table/types').HeaderCellClass>;
            headerCellStyle: import('vue').PropType<import('../ele-data-table/types').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: import('vue').PropType<import('../ele-data-table/types').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: import('vue').PropType<import('../ele-data-table/types').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').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').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').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').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').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').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').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').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').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: import('vue').PropType<import('../ele-data-table/types').FilterValue>;
                filterMultiple: BooleanConstructor;
                filters: import('vue').PropType<Column["filters"]>;
                filterPlacement: {
                    type: import('vue').PropType<EleTooltipProps["placement"]>;
                    default: string;
                };
            }>, {
                popperRef: Ref<import('../ele-app/plus').EleTooltipInstance, import('../ele-app/plus').EleTooltipInstance>;
                checkedValue: 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: import('vue').PropType<import('../ele-data-table/types').FilterValue>;
                filterMultiple: BooleanConstructor;
                filters: import('vue').PropType<Column["filters"]>;
                filterPlacement: {
                    type: import('vue').PropType<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').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').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').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').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').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').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').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').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/dist/vue.js').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').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').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/dist/vue.js').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').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').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/dist/vue.js').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').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').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').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').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/dist/vue.js').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').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/dist/vue.js').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').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/dist/vue.js').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').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').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').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').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').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').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').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').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').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').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').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').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: import('vue').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').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').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: import('vue').PropType<import('../ele-app/types').StyleValue>;
                }>, {
                    tooltipRef: 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: import('vue').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').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').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: import('vue').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').PropType<import('element-plus').Measurable>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            virtualTriggering: BooleanConstructor;
                            onMouseenter: {
                                readonly type: import('vue').PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onMouseleave: {
                                readonly type: import('vue').PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onClick: {
                                readonly type: import('vue').PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onKeydown: {
                                readonly type: import('vue').PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onFocus: {
                                readonly type: import('vue').PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onBlur: {
                                readonly type: import('vue').PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onContextmenu: {
                                readonly type: import('vue').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').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').PropType<import('vue').StyleValue>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            className: {
                                readonly type: import('vue').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').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').PropType<import('vue').StyleValue>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            referenceEl: {
                                readonly type: import('vue').PropType<HTMLElement>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            triggerTargetEl: {
                                readonly type: import('vue').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').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/dist/vue.js').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/dist/vue.js').Ref<import('element-plus').Measurable | undefined>;
                                    contentRef: import('vue/dist/vue.js').Ref<HTMLElement | undefined>;
                                    popperInstanceRef: import('vue/dist/vue.js').Ref<import('@popperjs/core').Instance | undefined>;
                                    referenceRef: import('vue/dist/vue.js').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/dist/vue.js').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/dist/vue.js').Ref<import('element-plus').Measurable | undefined>;
                                contentRef: import('vue/dist/vue.js').Ref<HTMLElement | undefined>;
                                popperInstanceRef: import('vue/dist/vue.js').Ref<import('@popperjs/core').Instance | undefined>;
                                referenceRef: import('vue/dist/vue.js').Ref<import('element-plus').Measurable | undefined>;
                                role: import('vue').ComputedRef<string>;
                            }> & {} & import('vue').ComponentCustomProperties & {
                                $slots: {
                                    default?(_: {}): any;
                                };
                            }) | undefined>;
                            contentRef: import('vue/dist/vue.js').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').PropType<import('element-plus').Measurable>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            virtualTriggering: BooleanConstructor;
                            onMouseenter: {
                                readonly type: import('vue').PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onMouseleave: {
                                readonly type: import('vue').PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onClick: {
                                readonly type: import('vue').PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onKeydown: {
                                readonly type: import('vue').PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onFocus: {
                                readonly type: import('vue').PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onBlur: {
                                readonly type: import('vue').PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onContextmenu: {
                                readonly type: import('vue').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').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').PropType<import('vue').StyleValue>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            className: {
                                readonly type: import('vue').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').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').PropType<import('vue').StyleValue>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            referenceEl: {
                                readonly type: import('vue').PropType<HTMLElement>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            triggerTargetEl: {
                                readonly type: import('vue').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').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/dist/vue.js').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/dist/vue.js').Ref<import('element-plus').Measurable | undefined>;
                                    contentRef: import('vue/dist/vue.js').Ref<HTMLElement | undefined>;
                                    popperInstanceRef: import('vue/dist/vue.js').Ref<import('@popperjs/core').Instance | undefined>;
                                    referenceRef: import('vue/dist/vue.js').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/dist/vue.js').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/dist/vue.js').Ref<import('element-plus').Measurable | undefined>;
                                contentRef: import('vue/dist/vue.js').Ref<HTMLElement | undefined>;
                                popperInstanceRef: import('vue/dist/vue.js').Ref<import('@popperjs/core').Instance | undefined>;
                                referenceRef: import('vue/dist/vue.js').Ref<import('element-plus').Measurable | undefined>;
                                role: import('vue').ComputedRef<string>;
                            }> & {} & import('vue').ComponentCustomProperties & {
                                $slots: {
                                    default?(_: {}): any;
                                };
                            }) | undefined>;
                            contentRef: import('vue/dist/vue.js').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').PropType<import('element-plus').Measurable>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        virtualTriggering: BooleanConstructor;
                        onMouseenter: {
                            readonly type: import('vue').PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onMouseleave: {
                            readonly type: import('vue').PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onClick: {
                            readonly type: import('vue').PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onKeydown: {
                            readonly type: import('vue').PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onFocus: {
                            readonly type: import('vue').PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onBlur: {
                            readonly type: import('vue').PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onContextmenu: {
                            readonly type: import('vue').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').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').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').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').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').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').PropType<HTMLElement>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        triggerTargetEl: {
                            readonly type: import('vue').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').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/dist/vue.js').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/dist/vue.js').Ref<import('element-plus').Measurable | undefined>;
                                contentRef: import('vue/dist/vue.js').Ref<HTMLElement | undefined>;
                                popperInstanceRef: import('vue/dist/vue.js').Ref<import('@popperjs/core').Instance | undefined>;
                                referenceRef: import('vue/dist/vue.js').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/dist/vue.js').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/dist/vue.js').Ref<import('element-plus').Measurable | undefined>;
                            contentRef: import('vue/dist/vue.js').Ref<HTMLElement | undefined>;
                            popperInstanceRef: import('vue/dist/vue.js').Ref<import('@popperjs/core').Instance | undefined>;
                            referenceRef: import('vue/dist/vue.js').Ref<import('element-plus').Measurable | undefined>;
                            role: import('vue').ComputedRef<string>;
                        }> & {} & import('vue').ComponentCustomProperties & {
                            $slots: {
                                default?(_: {}): any;
                            };
                        }) | undefined>;
                        contentRef: import('vue/dist/vue.js').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>;
    BodyRow: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        bodyCols: {
            type: import('vue').PropType<BodyColumns>;
            required: true;
        };
        colSizes: {
            type: import('vue').PropType<ColSize[]>;
            required: true;
        };
        rowIndex: {
            type: NumberConstructor;
            required: true;
        };
        rowItem: {
            type: import('vue').PropType<VirtualRow>;
            required: true;
        };
        rowId: import('vue').PropType<DataKey>;
        checkedRowKeys: import('vue').PropType<Set<DataKey>>;
        bodyCellClass: import('vue').PropType<import('../ele-data-table/types').CellClass>;
        bodyCellStyle: import('vue').PropType<import('../ele-data-table/types').CellStyle>;
        spanMethod: import('vue').PropType<import('../ele-data-table/types').SpanMethod>;
        tableTooltipProps: import('vue').PropType<import('../ele-data-table/types').ShowOverflowTooltip>;
        pageIndex: NumberConstructor;
        rowHeight: NumberConstructor;
        tableSize: import('vue').PropType<import('../ele-data-table/types').TableSize>;
        expandColumnKey: StringConstructor;
        expandedRowKeys: import('vue').PropType<DataKey[]>;
        lazy: BooleanConstructor;
        load: import('vue').PropType<import('../ele-data-table/types').TableLoad>;
        level: NumberConstructor;
        indent: NumberConstructor;
        fixedCellHeight: BooleanConstructor;
        autoRowHeight: BooleanConstructor;
    }>, {
        loading: 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: import('vue').PropType<BodyColumns>;
            required: true;
        };
        colSizes: {
            type: import('vue').PropType<ColSize[]>;
            required: true;
        };
        rowIndex: {
            type: NumberConstructor;
            required: true;
        };
        rowItem: {
            type: import('vue').PropType<VirtualRow>;
            required: true;
        };
        rowId: import('vue').PropType<DataKey>;
        checkedRowKeys: import('vue').PropType<Set<DataKey>>;
        bodyCellClass: import('vue').PropType<import('../ele-data-table/types').CellClass>;
        bodyCellStyle: import('vue').PropType<import('../ele-data-table/types').CellStyle>;
        spanMethod: import('vue').PropType<import('../ele-data-table/types').SpanMethod>;
        tableTooltipProps: import('vue').PropType<import('../ele-data-table/types').ShowOverflowTooltip>;
        pageIndex: NumberConstructor;
        rowHeight: NumberConstructor;
        tableSize: import('vue').PropType<import('../ele-data-table/types').TableSize>;
        expandColumnKey: StringConstructor;
        expandedRowKeys: import('vue').PropType<DataKey[]>;
        lazy: BooleanConstructor;
        load: import('vue').PropType<import('../ele-data-table/types').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: import('vue').PropType<BodyColumn>;
                required: true;
            };
            columnIndex: {
                type: NumberConstructor;
                required: true;
            };
            rowIndex: {
                type: NumberConstructor;
                required: true;
            };
            rowData: {
                type: import('vue').PropType<DataItem>;
                required: true;
            };
            colSizes: {
                type: import('vue').PropType<ColSize[]>;
                required: true;
            };
            bodyCellClass: import('vue').PropType<import('../ele-data-table/types').CellClass>;
            bodyCellStyle: import('vue').PropType<import('../ele-data-table/types').CellStyle>;
            spanMethod: import('vue').PropType<import('../ele-data-table/types').SpanMethod>;
            tableTooltipProps: import('vue').PropType<import('../ele-data-table/types').ShowOverflowTooltip>;
            pageIndex: NumberConstructor;
            rowHeight: NumberConstructor;
            isChecked: BooleanConstructor;
            isDisabled: BooleanConstructor;
            tableSize: import('vue').PropType<import('../ele-data-table/types').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: import('vue').PropType<BodyColumn>;
                required: true;
            };
            columnIndex: {
                type: NumberConstructor;
                required: true;
            };
            rowIndex: {
                type: NumberConstructor;
                required: true;
            };
            rowData: {
                type: import('vue').PropType<DataItem>;
                required: true;
            };
            colSizes: {
                type: import('vue').PropType<ColSize[]>;
                required: true;
            };
            bodyCellClass: import('vue').PropType<import('../ele-data-table/types').CellClass>;
            bodyCellStyle: import('vue').PropType<import('../ele-data-table/types').CellStyle>;
            spanMethod: import('vue').PropType<import('../ele-data-table/types').SpanMethod>;
            tableTooltipProps: import('vue').PropType<import('../ele-data-table/types').ShowOverflowTooltip>;
            pageIndex: NumberConstructor;
            rowHeight: NumberConstructor;
            isChecked: BooleanConstructor;
            isDisabled: BooleanConstructor;
            tableSize: import('vue').PropType<import('../ele-data-table/types').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: import('element-plus/es/utils/index').SFCWithInstall<{
                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                    readonly size: {
                        readonly type: import('vue').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').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').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').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').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').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;
                };
            })>;
            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: import('vue').PropType<import('../ele-data-table/types').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: import('vue').PropType<import('../ele-data-table/types').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').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').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').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').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').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').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').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').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').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>;
            CellRender: typeof import('./util').CellRender;
        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    ExpandRow: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        column: import('vue').PropType<Column>;
        rowIndex: NumberConstructor;
        rowData: import('vue').PropType<DataItem>;
    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        column: import('vue').PropType<Column>;
        rowIndex: NumberConstructor;
        rowData: import('vue').PropType<DataItem>;
    }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    FooterRow: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        bodyCols: {
            type: import('vue').PropType<BodyColumns>;
            required: true;
        };
        tableData: {
            type: import('vue').PropType<VirtualRow[]>;
            required: true;
        };
        colSizes: {
            type: import('vue').PropType<ColSize[]>;
            required: true;
        };
        sumWidth: NumberConstructor;
        rowHeight: NumberConstructor;
        sumText: StringConstructor;
        summaryMethod: import('vue').PropType<import('../ele-data-table/types').SummaryMethod>;
    }>, {
        sumCols: import('vue').ComputedRef<import('./types').SumCol[]>;
        handleMouseenter: (e: MouseEvent) => void;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
        mouseenter: (_e: MouseEvent) => true;
    }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        bodyCols: {
            type: import('vue').PropType<BodyColumns>;
            required: true;
        };
        tableData: {
            type: import('vue').PropType<VirtualRow[]>;
            required: true;
        };
        colSizes: {
            type: import('vue').PropType<ColSize[]>;
            required: true;
        };
        sumWidth: NumberConstructor;
        rowHeight: NumberConstructor;
        sumText: StringConstructor;
        summaryMethod: import('vue').PropType<import('../ele-data-table/types').SummaryMethod>;
    }>> & Readonly<{
        onMouseenter?: ((_e: MouseEvent) => any) | undefined;
    }>, {}, {}, {
        CellRender: typeof import('./util').CellRender;
    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
export default _default;