ele-admin-plus 1.1.6-beta.2 → 1.1.6-beta.4

package/lib/ele-tree-select/util.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("../utils/core");
+const util = require("../ele-basic-select/util");
+function getKeysAndList(data, valueKey, childrenKey) {
+  const keys = [];
+  const list = [];
+  core.eachTree(
+    data,
+    (d) => {
+      keys.push(d[valueKey]);
+      list.push(d);
+    },
+    childrenKey
+  );
+  return [keys, list];
+}
+function getNormalSelectedItems(data, checkedKeys, valueKey, labelKey, childrenKey, cacheData, checkedData) {
+  const selected = [];
+  if (util.isEmptyValue(checkedKeys) || !checkedKeys.length) {
+    return selected;
+  }
+  const cacheKeys = cacheData ? cacheData.map((d) => d[valueKey]) : [];
+  const ckKeys = checkedData ? checkedData.map((d) => d[valueKey]) : [];
+  const [dataKeys, list] = getKeysAndList(data, valueKey, childrenKey);
+  checkedKeys.forEach((key) => {
+    const index = cacheKeys.indexOf(key);
+    let item = cacheData && index !== -1 ? cacheData[index] : void 0;
+    if (index === -1 && checkedData) {
+      const tIndex = ckKeys.indexOf(key);
+      if (tIndex !== -1) {
+        item = checkedData[tIndex];
+      }
+    }
+    if (!item && data) {
+      const i = dataKeys.indexOf(key);
+      if (i !== -1) {
+        item = list[i];
+      }
+    }
+    selected.push({ value: key, label: item ? item[labelKey] : String(key) });
+  });
+  return selected;
+}
+function getTreeSelectedItems(data, checkedKeys, valueKey, labelKey, childrenKey, showParent, hide) {
+  const selected = [];
+  if (util.isEmptyValue(checkedKeys) || !checkedKeys.length) {
+    return selected;
+  }
+  if (data) {
+    data.forEach((d) => {
+      const value = d[valueKey];
+      const children = d[childrenKey];
+      const checked = checkedKeys.includes(value);
+      if (showParent) {
+        if (checked) {
+          selected.push({ value, label: d[labelKey], hide });
+        }
+        getTreeSelectedItems(
+          children,
+          checkedKeys,
+          valueKey,
+          labelKey,
+          childrenKey,
+          showParent,
+          checked ? true : hide
+        ).forEach((item) => {
+          selected.push(item);
+        });
+      } else {
+        const hasChildren = !!(children && children.length);
+        if (checked) {
+          selected.push({ value, label: d[labelKey], hide: hasChildren });
+        }
+        if (hasChildren) {
+          getTreeSelectedItems(
+            children,
+            checkedKeys,
+            valueKey,
+            labelKey,
+            childrenKey,
+            showParent
+          ).forEach((item) => {
+            selected.push(item);
+          });
+        }
+      }
+    });
+  }
+  return selected;
+}
+function checkSelectedItems(selected, checkedKeys, valueKey, labelKey, cacheData) {
+  const selectedValues = selected.map((s) => s.value);
+  const cacheKeys = cacheData ? cacheData.map((d) => d[valueKey]) : [];
+  checkedKeys.forEach((key) => {
+    if (!selectedValues.includes(key)) {
+      const index = cacheKeys.indexOf(key);
+      const item = cacheData && index !== -1 ? cacheData[index] : void 0;
+      selected.push({ value: key, label: item ? item[labelKey] : String(key) });
+    }
+  });
+  return selected;
+}
+function isCheckAll(data, checkedKeys, valueKey, childrenKey, disabledKey) {
+  if (!data || !data.length || !checkedKeys || !checkedKeys.length) {
+    return false;
+  }
+  return data.every((d) => {
+    if (d[disabledKey] || checkedKeys.includes(d[valueKey])) {
+      return true;
+    }
+    if (d[childrenKey] && d[childrenKey].length) {
+      return isCheckAll(
+        d[childrenKey],
+        checkedKeys,
+        valueKey,
+        childrenKey,
+        disabledKey
+      );
+    }
+    return false;
+  });
+}
+exports.checkSelectedItems = checkSelectedItems;
+exports.getKeysAndList = getKeysAndList;
+exports.getNormalSelectedItems = getNormalSelectedItems;
+exports.getTreeSelectedItems = getTreeSelectedItems;
+exports.isCheckAll = isCheckAll;

package/lib/ele-upload-list/index.d.ts

@@ -84,9 +84,9 @@ declare const _default: import("vue").DefineComponent<{
     disabled: boolean;
     readonly: boolean;
     sortable: boolean | Record<string | number | symbol, any>;
+    preview: boolean;
     drag: boolean;
     multiple: boolean;
-    preview: boolean;
     accept: string;
 }, {}>;
 export default _default;

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

@@ -136,9 +136,9 @@ declare const _default: import("vue").DefineComponent<{
     onMouseleave?: ((_row: DataItem, _col: Column, _e: MouseEvent) => any) | undefined;
     onClick?: ((_row: DataItem, _col: Column, _e: MouseEvent) => any) | undefined;
     onContextmenu?: ((_row: DataItem, _col: Column, _e: MouseEvent) => any) | undefined;
-    onDblclick?: ((_row: DataItem, _col: Column, _e: MouseEvent) => any) | undefined;
     onExpandChange?: ((_row: DataItem, _expanded: boolean) => any) | undefined;
     onCheckedChange?: ((_row: DataItem, _checked: boolean) => any) | undefined;
+    onDblclick?: ((_row: DataItem, _col: Column, _e: MouseEvent) => any) | undefined;
 }, {
     loading: boolean;
     isChecked: boolean;

package/lib/ele-virtual-table/components/body-row.d.ts

@@ -11,7 +11,7 @@ declare const _default: import("vue").DefineComponent<{
     /** 当前行数据 */
     rowData: PropType<DataItem>;
     /** 表格多选选中的值 */
-    selectedRowKeys: PropType<Set<DataKey>>;
+    checkedRowKeys: PropType<Set<DataKey>>;
     /** 是否禁用表头选择框 */
     tableSize: PropType<"" | "default" | "small" | "large" | undefined>;
     /** 单元格类名自定义 */
@@ -91,7 +91,7 @@ declare const _default: import("vue").DefineComponent<{
     /** 当前行数据 */
     rowData: PropType<DataItem>;
     /** 表格多选选中的值 */
-    selectedRowKeys: PropType<Set<DataKey>>;
+    checkedRowKeys: PropType<Set<DataKey>>;
     /** 是否禁用表头选择框 */
     tableSize: PropType<"" | "default" | "small" | "large" | undefined>;
     /** 单元格类名自定义 */
@@ -136,9 +136,9 @@ declare const _default: import("vue").DefineComponent<{
     onCellClick?: ((_row: DataItem, _col: Column, _e: MouseEvent) => any) | undefined;
     onCellDblclick?: ((_row: DataItem, _col: Column, _e: MouseEvent) => any) | undefined;
     onCellContextmenu?: ((_row: DataItem, _col: Column, _e: MouseEvent) => any) | undefined;
+    onCellMouseenter?: ((_row: DataItem, _col: Column, _e: MouseEvent) => any) | undefined;
     onCellCheckedChange?: ((_row: DataItem, _checked: boolean) => any) | undefined;
     onCellExpandChange?: ((_row: DataItem, _expanded: boolean, _data?: DataItem[] | undefined) => any) | undefined;
-    onCellMouseenter?: ((_row: DataItem, _col: Column, _e: MouseEvent) => any) | undefined;
     onCellMouseleave?: ((_row: DataItem, _col: Column, _e: MouseEvent) => any) | undefined;
 }, {
     lazy: boolean;

package/lib/ele-virtual-table/components/body-row.js

@@ -14,7 +14,7 @@ const _sfc_main = vue.defineComponent({
     /** 当前行数据 */
     rowData: Object,
     /** 表格多选选中的值 */
-    selectedRowKeys: Set,
+    checkedRowKeys: Set,
     /** 是否禁用表头选择框 */
     tableSize: String,
     /** 单元格类名自定义 */
@@ -70,10 +70,10 @@ const _sfc_main = vue.defineComponent({
       return props.rowData ? props.rowData._rowKey : void 0;
     });
     const isChecked = vue.computed(() => {
-      if (!props.selectedRowKeys || !rowDataKey.value) {
+      if (!props.checkedRowKeys || !rowDataKey.value) {
         return false;
       }
-      return props.selectedRowKeys.has(rowDataKey.value);
+      return props.checkedRowKeys.has(rowDataKey.value);
     });
     const hasChildren = vue.computed(() => {
       if (props.rowData) {

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

@@ -1,6 +1,6 @@
 import type { PropType } from 'vue';
 import type { FilterValue } from '../../ele-data-table/types';
-import type { EleTooltipInstance } from '../../ele-app/types/components';
+import type { EleTooltipInstance } from '../../ele-app/types';
 declare const _default: import("vue").DefineComponent<{
     /** 选中项 */
     filtered: PropType<FilterValue>;

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

@@ -89,9 +89,9 @@ declare const _default: import("vue").DefineComponent<{
     onFilterChange?: ((_params: CellFilterChangeParams) => any) | undefined;
     onCheckedChange?: ((_checked: boolean) => any) | undefined;
 }, {
+    isIndeterminate: boolean;
     headerEllipsis: boolean;
     isCheckAll: boolean;
-    isIndeterminate: boolean;
     disabledCheckbox: boolean;
 }, {}>;
 export default _default;

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

@@ -81,9 +81,9 @@ declare const _default: import("vue").DefineComponent<{
     onCheckedChange?: ((_checked: boolean) => any) | undefined;
     onCellMouseenter?: ((_col: Column, _e: MouseEvent) => any) | undefined;
 }, {
+    isIndeterminate: boolean;
     headerEllipsis: boolean;
     isCheckAll: boolean;
-    isIndeterminate: boolean;
     disabledCheckbox: boolean;
 }, {}>;
 export default _default;

package/lib/ele-virtual-table/index.d.ts

@@ -0,0 +1,386 @@
+import type { Ref } from 'vue';
+import type { ElTableV2Instance, ElTableV2Props } from '../ele-app/types';
+import type { DataKey, DataItem, Column, Filter, OrderValue } from '../ele-data-table/types';
+import type { BodyColumns, HeaderRows, CellFilterChangeParams, SortBy, ScrollStrategy, ScrollPos, ColSize } from './types';
+declare const _default: import("vue").DefineComponent<{
+    rowHeight: NumberConstructor;
+    stripe: {
+        type: BooleanConstructor;
+        default: null;
+    };
+    border: {
+        type: BooleanConstructor;
+        default: null;
+    };
+    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, "" | "default" | "small" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    maxHeight: (StringConstructor | NumberConstructor)[];
+    fit: {
+        type: BooleanConstructor; /** 是否是树形数据 */
+        default: boolean;
+    };
+    className: {
+        type: StringConstructor;
+        default: string;
+    };
+    width: (StringConstructor | NumberConstructor)[];
+    lazy: BooleanConstructor;
+    rowKey: import("vue").PropType<string | ((row: any) => string) | undefined>;
+    data: {
+        type: import("vue").PropType<any[]>;
+        default: () => never[];
+    };
+    height: (StringConstructor | NumberConstructor)[];
+    scrollbarAlwaysOn: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showOverflowTooltip: import("vue").PropType<boolean | Partial<Pick<import("element-plus").ElTooltipProps, "offset" | "effect" | "placement" | "popperOptions" | "popperClass" | "showArrow" | "enterable" | "showAfter" | "hideAfter">> | undefined>;
+    emptyText: StringConstructor;
+    indent: {
+        type: NumberConstructor;
+        default: number;
+    };
+    showHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showSummary: BooleanConstructor;
+    sumText: StringConstructor;
+    summaryMethod: import("vue").PropType<import("element-plus/es/components/table/src/table/defaults").SummaryMethod<any> | undefined>;
+    rowClassName: import("vue").PropType<import("element-plus/es/components/table/src/table/defaults").ColumnCls<any> | undefined>;
+    rowStyle: import("vue").PropType<import("element-plus/es/components/table/src/table/defaults").ColumnStyle<any> | undefined>;
+    cellClassName: import("vue").PropType<import("element-plus/es/components/table/src/table/defaults").CellCls<any> | undefined>;
+    cellStyle: import("vue").PropType<import("element-plus/es/components/table/src/table/defaults").CellStyle<any> | undefined>;
+    headerRowClassName: import("vue").PropType<import("element-plus/es/components/table/src/table/defaults").ColumnCls<any> | undefined>;
+    headerRowStyle: import("vue").PropType<import("element-plus/es/components/table/src/table/defaults").ColumnStyle<any> | undefined>;
+    headerCellClassName: import("vue").PropType<import("element-plus/es/components/table/src/table/defaults").CellCls<any> | undefined>;
+    headerCellStyle: import("vue").PropType<import("element-plus/es/components/table/src/table/defaults").CellStyle<any> | undefined>;
+    highlightCurrentRow: BooleanConstructor;
+    currentRowKey: (StringConstructor | NumberConstructor)[];
+    expandRowKeys: import("vue").PropType<any[] | undefined>;
+    defaultExpandAll: BooleanConstructor;
+    defaultSort: import("vue").PropType<import("element-plus/es/components/table/src/table/defaults").Sort | undefined>;
+    tooltipEffect: StringConstructor;
+    tooltipOptions: import("vue").PropType<Partial<Pick<import("element-plus").ElTooltipProps, "offset" | "effect" | "placement" | "popperOptions" | "popperClass" | "showArrow" | "enterable" | "showAfter" | "hideAfter">> | undefined>;
+    spanMethod: import("vue").PropType<((data: {
+        row: any;
+        rowIndex: number;
+        column: import("element-plus/es/components/table/src/table-column/defaults").TableColumnCtx<any>;
+        columnIndex: number;
+    }) => number[] | {
+        rowspan: number;
+        colspan: number;
+    } | undefined) | undefined>;
+    selectOnIndeterminate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    treeProps: {
+        type: import("vue").PropType<{
+            hasChildren?: string | undefined;
+            children?: string | undefined;
+        } | undefined>;
+        default: () => {
+            hasChildren: string;
+            children: string;
+        };
+    };
+    load: import("vue").PropType<((row: any, treeNode: import("element-plus/es/components/table/src/table/defaults").TreeNode, resolve: (data: any[]) => void) => void) | undefined>;
+    tableLayout: {
+        type: import("vue").PropType<"auto" | "fixed">;
+        default: string;
+    };
+    flexible: BooleanConstructor;
+}, {
+    rootRef: Ref<HTMLElement | null>;
+    tableRef: Ref<ElTableV2Instance>;
+    tableKey: Ref<number>;
+    wrapWidth: Ref<number>;
+    headerRows: Ref<HeaderRows>;
+    bodyCols: Ref<BodyColumns>;
+    headerRowSizes: Ref<ColSize[][]>;
+    bodyColSizes: Ref<ColSize[]>;
+    colsSumWidth: Ref<number>;
+    tableWidth: Ref<number>;
+    tableData: Ref<DataItem[]>;
+    isCheckAll: Ref<boolean>;
+    isIndeterminate: import("vue").ComputedRef<boolean>;
+    checkedRowKeys: Ref<Set<DataKey>>;
+    expandedRowKeys: Ref<DataKey[]>;
+    sortBy: Ref<SortBy | undefined>;
+    filtered: Filter;
+    tableTooltipProps: Partial<import("../ele-tooltip/props").TooltipProps>;
+    treeHasChildrenName: import("vue").ComputedRef<string>;
+    tableExpandCol: import("vue").ComputedRef<Partial<import("element-plus").Column<DataItem>> | 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>;
+    tableEmptyProps: import("vue").ComputedRef<import("../ele-app/types").ElEmptyProps>;
+    onTableFilterChange: (params: CellFilterChangeParams) => void;
+    onCellCheckedChange: (row: DataItem, checked: boolean) => void;
+    onCellExpandChange: (row: DataItem, expanded: boolean, children?: DataItem[]) => void;
+    onCellClick: (row: DataItem, col: Column, e: MouseEvent) => void;
+    onCellDblclick: (row: DataItem, col: Column, e: MouseEvent) => void;
+    onCellContextmenu: (row: DataItem, col: Column, e: MouseEvent) => void;
+    onCellMouseenter: (row: DataItem, col: Column, e: MouseEvent) => void;
+    onCellMouseleave: (row: DataItem, col: Column, e: MouseEvent) => void;
+    onHeaderCellClick: (col: Column | undefined, e: MouseEvent) => void;
+    onHeaderCellContextmenu: (col: Column, e: MouseEvent) => void;
+    onHeaderCellMouseenter: () => void;
+    onFooterCellMouseenter: (e: MouseEvent) => void;
+    onExpandCellMouseenter: () => void;
+    onTableMouseleave: () => void;
+    onTableScroll: (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: DataItem, 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;
+}, unknown, {}, {}, 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 | undefined, _old?: DataItem | null | undefined) => boolean;
+    headerDragend: (_width: number, _old: number, _column: Column, _e: MouseEvent) => boolean;
+    expandChange: (_row: DataItem, _expanded: boolean) => boolean;
+    'update:currentRowKey': (_currentRowKey?: DataKey | undefined) => boolean;
+    'update:selectedRowKeys': (_selectedRowKeys?: DataKey[] | undefined) => boolean;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    rowHeight: NumberConstructor;
+    stripe: {
+        type: BooleanConstructor;
+        default: null;
+    };
+    border: {
+        type: BooleanConstructor;
+        default: null;
+    };
+    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, "" | "default" | "small" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    maxHeight: (StringConstructor | NumberConstructor)[];
+    fit: {
+        type: BooleanConstructor; /** 是否是树形数据 */
+        default: boolean;
+    };
+    className: {
+        type: StringConstructor;
+        default: string;
+    };
+    width: (StringConstructor | NumberConstructor)[];
+    lazy: BooleanConstructor;
+    rowKey: import("vue").PropType<string | ((row: any) => string) | undefined>;
+    data: {
+        type: import("vue").PropType<any[]>;
+        default: () => never[];
+    };
+    height: (StringConstructor | NumberConstructor)[];
+    scrollbarAlwaysOn: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showOverflowTooltip: import("vue").PropType<boolean | Partial<Pick<import("element-plus").ElTooltipProps, "offset" | "effect" | "placement" | "popperOptions" | "popperClass" | "showArrow" | "enterable" | "showAfter" | "hideAfter">> | undefined>;
+    emptyText: StringConstructor;
+    indent: {
+        type: NumberConstructor;
+        default: number;
+    };
+    showHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showSummary: BooleanConstructor;
+    sumText: StringConstructor;
+    summaryMethod: import("vue").PropType<import("element-plus/es/components/table/src/table/defaults").SummaryMethod<any> | undefined>;
+    rowClassName: import("vue").PropType<import("element-plus/es/components/table/src/table/defaults").ColumnCls<any> | undefined>;
+    rowStyle: import("vue").PropType<import("element-plus/es/components/table/src/table/defaults").ColumnStyle<any> | undefined>;
+    cellClassName: import("vue").PropType<import("element-plus/es/components/table/src/table/defaults").CellCls<any> | undefined>;
+    cellStyle: import("vue").PropType<import("element-plus/es/components/table/src/table/defaults").CellStyle<any> | undefined>;
+    headerRowClassName: import("vue").PropType<import("element-plus/es/components/table/src/table/defaults").ColumnCls<any> | undefined>;
+    headerRowStyle: import("vue").PropType<import("element-plus/es/components/table/src/table/defaults").ColumnStyle<any> | undefined>;
+    headerCellClassName: import("vue").PropType<import("element-plus/es/components/table/src/table/defaults").CellCls<any> | undefined>;
+    headerCellStyle: import("vue").PropType<import("element-plus/es/components/table/src/table/defaults").CellStyle<any> | undefined>;
+    highlightCurrentRow: BooleanConstructor;
+    currentRowKey: (StringConstructor | NumberConstructor)[];
+    expandRowKeys: import("vue").PropType<any[] | undefined>;
+    defaultExpandAll: BooleanConstructor;
+    defaultSort: import("vue").PropType<import("element-plus/es/components/table/src/table/defaults").Sort | undefined>;
+    tooltipEffect: StringConstructor;
+    tooltipOptions: import("vue").PropType<Partial<Pick<import("element-plus").ElTooltipProps, "offset" | "effect" | "placement" | "popperOptions" | "popperClass" | "showArrow" | "enterable" | "showAfter" | "hideAfter">> | undefined>;
+    spanMethod: import("vue").PropType<((data: {
+        row: any;
+        rowIndex: number;
+        column: import("element-plus/es/components/table/src/table-column/defaults").TableColumnCtx<any>;
+        columnIndex: number;
+    }) => number[] | {
+        rowspan: number;
+        colspan: number;
+    } | undefined) | undefined>;
+    selectOnIndeterminate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    treeProps: {
+        type: import("vue").PropType<{
+            hasChildren?: string | undefined;
+            children?: string | undefined;
+        } | undefined>;
+        default: () => {
+            hasChildren: string;
+            children: string;
+        };
+    };
+    load: import("vue").PropType<((row: any, treeNode: import("element-plus/es/components/table/src/table/defaults").TreeNode, resolve: (data: any[]) => void) => void) | undefined>;
+    tableLayout: {
+        type: import("vue").PropType<"auto" | "fixed">;
+        default: string;
+    };
+    flexible: BooleanConstructor;
+}>> & {
+    onSelect?: ((_selection: DataItem[], _row: DataItem) => 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;
+    onFilterChange?: ((_filter: Filter) => 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;
+    className: string;
+    lazy: boolean;
+    data: any[];
+    scrollbarAlwaysOn: boolean;
+    indent: number;
+    stripe: boolean;
+    border: boolean;
+    showHeader: boolean;
+    showSummary: boolean;
+    highlightCurrentRow: boolean;
+    defaultExpandAll: boolean;
+    selectOnIndeterminate: boolean;
+    treeProps: {
+        hasChildren?: string | undefined;
+        children?: string | undefined;
+    } | undefined;
+    tableLayout: "auto" | "fixed";
+    flexible: boolean;
+    headerEllipsis: boolean;
+    slotNormalize: boolean;
+    sticky: boolean;
+    bottomLine: boolean;
+    emptyProps: import("../ele-data-table/types").TableEmptyProps;
+    reserveCurrent: boolean;
+}, {}>;
+export default _default;