ele-admin-plus 1.1.4 → 1.1.5-beta.2

package/es/ele-data-table/util.d.ts

@@ -0,0 +1,163 @@
+import type { Slots, VNode } from 'vue';
+import type { Emitter, ElEmptyProps, ElTableInstance } from '../ele-app/types';
+import type { DataItem, Column, Columns, Sorter, Filter, GetInstance, TableMethods, ShowOverflowTooltip, TooltipEffect, TooltipOptions, RowClass, TableState } from './types';
+import type { dataTableEmits } from './props';
+/**
+ * 获取数据某字段值
+ * @param data 数据
+ * @param field 字段, 可嵌套 a.b.c
+ */
+export declare function getValue<T, K>(data: K, field?: string | ((d: K) => T)): T | undefined;
+/**
+ * 递归获取表格列节点
+ * @param cols 列配置
+ * @param pageIndex 序号列起始值
+ * @param slots 插槽对象
+ * @param slotNormalize 是否过滤非正常的插槽渲染
+ * @param globalTooltip 表格提示组件属性
+ */
+export declare function getCols(cols: Columns | undefined, pageIndex: number | undefined, slots: Slots, slotNormalize: boolean, globalTooltip?: ShowOverflowTooltip): VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[];
+/**
+ * 获取行的类名
+ * @param rowClass 自定义行类名
+ * @param param 方法类型的参数
+ */
+export declare function getRowClass(rowClass: RowClass | undefined, param: Parameters<Exclude<RowClass, string | undefined>>[0]): string | undefined;
+/**
+ * 获取行的类名
+ * @param rowClass 自定义行类名
+ * @param param 方法类型的参数
+ */
+export declare function getBodyRowClass(rowClass: RowClass | undefined, param: Parameters<Exclude<RowClass, string | undefined>>[0]): string;
+/**
+ * 获取表头行的类名
+ * @param rowClass 自定义行类名
+ * @param param 方法类型的参数
+ * @param ellipsis 是否单行省略
+ */
+export declare function getHeadRowClass(rowClass: RowClass | undefined, param: Parameters<Exclude<RowClass, string | undefined>>[0], ellipsis: boolean): string;
+/**
+ * 合并提示组件相关属性
+ * @param props showOverflowTooltip
+ * @param globalProps tableOverflowTooltip
+ */
+export declare function mergeTooltipProps(props?: ShowOverflowTooltip, globalProps?: ShowOverflowTooltip): Exclude<ShowOverflowTooltip, true>;
+/**
+ * 获取全局溢出提示组件属性
+ * @param showOverflowTooltip 溢出提示组件属性
+ * @param tooltipEffect 溢出提示组件主题
+ * @param tooltipOptions 溢出提示组件配置
+ */
+export declare function getGlobalTooltipProps(showOverflowTooltip?: ShowOverflowTooltip, tooltipEffect?: TooltipEffect, tooltipOptions?: TooltipOptions): ShowOverflowTooltip;
+/**
+ * 获取单元格提示组件属性
+ * @param props 单元格提示组件属性
+ * @param globalProps 表格提示组件属性
+ */
+export declare function getTooltipProps(props?: ShowOverflowTooltip, globalProps?: ShowOverflowTooltip): ShowOverflowTooltip;
+/**
+ * 渲染插槽
+ * @param slots 插槽对象
+ * @param name 插槽名称
+ * @param props 插槽数据
+ */
+export declare function renderSlot(slots: Slots, name?: string, props?: any): VNode[] | undefined;
+/**
+ * 获取插槽
+ * @param slots 插槽对象
+ * @param name 插槽名称
+ */
+export declare function getSlot(slots: Slots, name?: string): import("vue").Slot<any> | undefined;
+/**
+ * 获取空组件属性
+ * @param emptyProps 空组件属性
+ * @param emptyText 空文本
+ * @param errorText 错误文本
+ */
+export declare function getEmptyProps(emptyProps?: boolean | ElEmptyProps, emptyText?: string, errorText?: string): ElEmptyProps;
+/**
+ * 获取空状态插槽
+ * @param slots 插槽对象
+ * @param emptyProps 空组件属性
+ * @param emptyText 空文本
+ * @param errorText 错误文本
+ */
+export declare function getEmptySlot(slots: Slots, emptyProps?: boolean | ElEmptyProps, emptyText?: string, errorText?: string): (() => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined) | undefined;
+/**
+ * 获取表格筛选值
+ * @param tableRef 表格实例
+ */
+export declare function getTableFilter(tableRef?: ElTableInstance): Filter | undefined;
+/**
+ * 获取含表格状态的列配置
+ * @param cols 表格的列
+ * @param sorter 当前排序状态
+ * @param filter 当前筛选状态
+ */
+export declare function getStateCols(cols: Columns, sorter?: Sorter, filter?: Filter): {
+    cols: Columns;
+    sorter: Sorter | undefined;
+};
+/**
+ * 获取判断多选是否可选择的方法
+ * @param columns 列配置
+ */
+export declare function getSelectableFunc(columns?: Columns): ((row: any, index: number) => boolean) | null | undefined;
+/**
+ * 判断行是否禁止多选
+ * @param row 行数据
+ * @param index 行索引
+ * @param columns 列配置
+ */
+export declare function isDisableRow(row: DataItem, index: number, columns?: Columns): boolean;
+/**
+ * 判断是否保存不存在的选中数据
+ * @param columns 列配置
+ */
+export declare function isReserveSelected(columns?: Columns): boolean;
+/**
+ * 表格状态数据
+ */
+export declare function useState(defaultSort: TableState['sorter']): {
+    getSorter: () => Sorter | undefined;
+    setSorter: (value: Sorter) => void;
+    getFilter: () => Filter | undefined;
+    setFilter: (value: Filter) => void;
+    getSelectionNoChange: (value?: boolean) => boolean;
+    setSelectionNoChange: (value?: boolean) => boolean;
+};
+/**
+ * 表格实例方法
+ * @param getInstance 获取表格实例方法
+ */
+export declare function useMethods(getInstance: GetInstance): TableMethods;
+/**
+ * 表格事件
+ * @param emit 事件触发器
+ */
+export declare function useEmits(emit: Emitter<typeof dataTableEmits>): {
+    onSelect: (selection: DataItem[], row: DataItem) => void;
+    onSelectAll: (selection: DataItem[]) => void;
+    onCellMouseEnter: (row: DataItem, column: Column, cell: HTMLTableCellElement, event: MouseEvent) => void;
+    onCellMouseLeave: (row: DataItem, column: Column, cell: HTMLTableCellElement, event: MouseEvent) => void;
+    onCellClick: (row: DataItem, column: Column, cell: HTMLTableCellElement, event: MouseEvent) => void;
+    onCellDblclick: (row: DataItem, column: Column, cell: HTMLTableCellElement, event: MouseEvent) => void;
+    onCellContextmenu: (row: DataItem, column: Column, cell: HTMLTableCellElement, event: MouseEvent) => void;
+    onRowClick: (row: DataItem, column: Column, event: MouseEvent) => void;
+    onRowContextmenu: (row: DataItem, column: Column, event: MouseEvent) => void;
+    onRowDblclick: (row: DataItem, column: Column, event: MouseEvent) => void;
+    onHeaderClick: (column: Column, event: MouseEvent) => void;
+    onHeaderContextmenu: (column: Column, event: MouseEvent) => void;
+    onHeaderDragend: (newWidth: number, oldWidth: number, column: Column, event: MouseEvent) => void;
+    onExpandChange: (row: DataItem | undefined, expanded: boolean | DataItem[]) => void;
+    onSelectionChange: (selection: DataItem[]) => void;
+    onSortChange: (sorter: Sorter) => void;
+    onFilterChange: (filter: Filter) => void;
+    onCurrentChange: (currentRow?: DataItem | null, oldCurrentRow?: DataItem | null) => void;
+};

package/es/ele-data-table/util.js

@@ -0,0 +1,417 @@
+import { h, unref } from "vue";
+import { ElTableColumn, ElEmpty } from "element-plus";
+import { omit, mapTree, eachTree } from "../utils/core";
+function getValue(data, field) {
+  if (typeof field === "function") {
+    return field(data);
+  }
+  if (field == null || field === "") {
+    return;
+  }
+  let value = data;
+  field.split(".").forEach((f) => {
+    value = value ? value[f] : null;
+  });
+  return value;
+}
+function getCols(cols, pageIndex, slots, slotNormalize, globalTooltip) {
+  const nodes = [];
+  if (cols) {
+    cols.forEach((col) => {
+      nodes.push(
+        h(
+          ElTableColumn,
+          {
+            ...omit(col, [
+              "showOverflowTooltip",
+              "uid",
+              "slot",
+              "headerSlot",
+              "hideInTable",
+              "hideInSetting",
+              "children"
+            ]),
+            showOverflowTooltip: getTooltipProps(
+              col.showOverflowTooltip,
+              globalTooltip
+            ),
+            columnKey: col.columnKey ?? col.prop,
+            index: col.index ?? pageIndex,
+            key: col.uid
+          },
+          {
+            default: (slotProps) => {
+              const tSlot = getSlot(slots, col.slot);
+              const $index = slotProps == null ? void 0 : slotProps.$index;
+              if (!tSlot || $index == -1 && slotNormalize) {
+                return getCols(
+                  col.children,
+                  pageIndex,
+                  slots,
+                  slotNormalize,
+                  globalTooltip
+                );
+              }
+              return tSlot(slotProps);
+            },
+            header: (slotProps) => {
+              var _a;
+              const title = (_a = slotProps == null ? void 0 : slotProps.column) == null ? void 0 : _a.label;
+              const nodes2 = renderSlot(slots, col.headerSlot, slotProps);
+              return h(
+                "div",
+                { class: "ele-cell-title", title },
+                nodes2 ?? title
+              );
+            }
+          }
+        )
+      );
+    });
+  }
+  return nodes;
+}
+function getRowClass(rowClass, param) {
+  if (rowClass != null) {
+    if (typeof rowClass === "function") {
+      return rowClass(param);
+    } else if (typeof rowClass === "string" && rowClass) {
+      return rowClass;
+    }
+  }
+}
+function getBodyRowClass(rowClass, param) {
+  const classes = ["ele-table-tr"];
+  const custom = getRowClass(rowClass, param);
+  if (custom != null) {
+    classes.push(custom);
+  }
+  return classes.join(" ");
+}
+function getHeadRowClass(rowClass, param, ellipsis) {
+  const classes = ["ele-table-head-tr"];
+  if (ellipsis) {
+    classes.push("is-ellipsis");
+  }
+  const custom = getRowClass(rowClass, param);
+  if (custom != null) {
+    classes.push(custom);
+  }
+  return classes.join(" ");
+}
+function mergeTooltipProps(props, globalProps) {
+  if (props === false || props == null && !globalProps) {
+    return false;
+  }
+  return {
+    ...!globalProps || globalProps === true ? {} : globalProps,
+    ...!props || props === true ? {} : props
+  };
+}
+function getGlobalTooltipProps(showOverflowTooltip, tooltipEffect, tooltipOptions) {
+  if (!showOverflowTooltip) {
+    return false;
+  }
+  return {
+    effect: tooltipEffect,
+    ...tooltipOptions || {},
+    ...showOverflowTooltip === true ? {} : showOverflowTooltip
+  };
+}
+function getTooltipProps(props, globalProps) {
+  const opt = mergeTooltipProps(props, globalProps);
+  if (!opt) {
+    return false;
+  }
+  const classes = ["ele-popper", "ele-tooltip", "ele-table-tooltip"];
+  if (opt.popperClass) {
+    classes.push(opt.popperClass);
+  }
+  opt.popperClass = classes.join(" ");
+  return opt;
+}
+function renderSlot(slots, name, props) {
+  const slot = getSlot(slots, name);
+  if (slot != null) {
+    return slot(props || {});
+  }
+}
+function getSlot(slots, name) {
+  if (name && slots[name] != null && typeof slots[name] === "function") {
+    return slots[name];
+  }
+}
+function getEmptyProps(emptyProps, emptyText, errorText) {
+  if (emptyProps === false) {
+    return {};
+  }
+  return {
+    imageSize: 68,
+    ...!emptyProps || emptyProps === true ? {} : emptyProps,
+    description: errorText || emptyText,
+    class: "ele-table-empty"
+  };
+}
+function getEmptySlot(slots, emptyProps, emptyText, errorText) {
+  const emptySlot = slots.empty;
+  if (!emptyProps && !emptySlot) {
+    return;
+  }
+  return () => {
+    if (emptySlot) {
+      return emptySlot({ text: emptyText, error: errorText });
+    }
+    if (emptyProps) {
+      return h(ElEmpty, getEmptyProps(emptyProps, emptyText, errorText));
+    }
+  };
+}
+function getTableFilter(tableRef) {
+  var _a, _b;
+  const states = (_b = (_a = unref(tableRef)) == null ? void 0 : _a.store) == null ? void 0 : _b.states;
+  const columns = unref(states == null ? void 0 : states.columns);
+  const filters = unref(states == null ? void 0 : states.filters);
+  if (!filters || !columns) {
+    return;
+  }
+  const keys = Object.keys(filters);
+  const filter = {};
+  columns.forEach((col) => {
+    if (keys.includes(col.id)) {
+      filter[col.columnKey || col.id] = filters[col.id];
+    }
+  });
+  return filter;
+}
+function getStateCols(cols, sorter, filter) {
+  if (!sorter && !filter) {
+    return { cols, sorter: void 0 };
+  }
+  const filterKeys = filter == null ? [] : Object.keys(filter);
+  const hasSorter = sorter != null && sorter.prop != null && sorter.prop != "";
+  let hasSortCol = false;
+  const result = mapTree(cols, (col) => {
+    if (hasSorter && col.prop === sorter.prop) {
+      hasSortCol = true;
+    }
+    const filterProp = col.columnKey ?? col.prop;
+    const t = filterProp && filterKeys.includes(filterProp);
+    const filtered = t && filter ? filter[filterProp] : void 0;
+    return { ...col, filteredValue: filtered ?? col.filteredValue };
+  });
+  return { cols: result, sorter: hasSorter && hasSortCol ? sorter : void 0 };
+}
+function getSelectableFunc(columns) {
+  let selectable;
+  eachTree(columns, (col) => {
+    if (col.type === "selection") {
+      selectable = typeof col.selectable === "function" ? col.selectable : null;
+      return false;
+    }
+  });
+  return selectable;
+}
+function isDisableRow(row, index, columns) {
+  const selectable = getSelectableFunc(columns);
+  if (typeof selectable === "undefined") {
+    return true;
+  }
+  return !(selectable == null || selectable(row, index) === true);
+}
+function isReserveSelected(columns) {
+  let isReserve = false;
+  eachTree(columns, (col) => {
+    if (col.type === "selection") {
+      isReserve = !!col.reserveSelection;
+      return false;
+    }
+  });
+  return isReserve;
+}
+function useState(defaultSort) {
+  const state = { sorter: defaultSort };
+  const getSorter = () => {
+    return state.sorter;
+  };
+  const setSorter = (value) => {
+    state.sorter = value;
+  };
+  const getFilter = () => {
+    return state.filter;
+  };
+  const setFilter = (value) => {
+    state.filter = value;
+  };
+  const getSelectionNoChange = (value) => {
+    if (value != null) {
+      state.selectionNoChange = value;
+    }
+    return !!state.selectionNoChange;
+  };
+  const setSelectionNoChange = (value) => {
+    if (value != null) {
+      state.selectionNoChange = value;
+    }
+    return !!state.selectionNoChange;
+  };
+  return {
+    getSorter,
+    setSorter,
+    getFilter,
+    setFilter,
+    getSelectionNoChange,
+    setSelectionNoChange
+  };
+}
+function useMethods(getInstance) {
+  const methods = {
+    clearSelection: () => {
+      const ins = getInstance();
+      ins && ins.clearSelection();
+    },
+    getSelectionRows: () => {
+      const ins = getInstance();
+      if (ins) {
+        return ins.getSelectionRows();
+      }
+    },
+    toggleRowSelection: (row, selected) => {
+      const ins = getInstance();
+      ins && ins.toggleRowSelection(row, selected);
+    },
+    toggleAllSelection: () => {
+      const ins = getInstance();
+      ins && ins.toggleAllSelection();
+    },
+    toggleRowExpansion: (row, expanded) => {
+      const ins = getInstance();
+      ins && ins.toggleRowExpansion(row, expanded);
+    },
+    setCurrentRow: (row) => {
+      const ins = getInstance();
+      ins && ins.setCurrentRow(row);
+    },
+    clearSort: () => {
+      const ins = getInstance();
+      ins && ins.clearSort();
+    },
+    clearFilter: (columnKeys) => {
+      const ins = getInstance();
+      ins && ins.clearFilter(columnKeys);
+    },
+    doLayout: () => {
+      const ins = getInstance();
+      ins && ins.doLayout();
+    },
+    sort: (prop, order) => {
+      const ins = getInstance();
+      ins && ins.sort(prop, order);
+    },
+    scrollTo: (options, yCoord) => {
+      const ins = getInstance();
+      ins && ins.scrollTo(options, yCoord);
+    },
+    setScrollTop: (top) => {
+      const ins = getInstance();
+      ins && ins.setScrollTop(top);
+    },
+    setScrollLeft: (left) => {
+      const ins = getInstance();
+      ins && ins.setScrollLeft(left);
+    },
+    /** 新增的需要实现的实例方法 */
+    setSelectedRows: (rows) => {
+      const ins = getInstance();
+      ins && ins.setSelectedRows(rows);
+    },
+    setSelectedRowKeys: (keys) => {
+      const ins = getInstance();
+      ins && ins.setSelectedRowKeys(keys);
+    },
+    toggleRowExpansionAll: (expanded) => {
+      const ins = getInstance();
+      ins && ins.toggleRowExpansionAll(expanded);
+    }
+  };
+  return methods;
+}
+function useEmits(emit) {
+  return {
+    onSelect: (selection, row) => {
+      emit("select", selection, row);
+    },
+    onSelectAll: (selection) => {
+      emit("selectAll", selection);
+    },
+    onCellMouseEnter: (row, column, cell, event) => {
+      emit("cellMouseEnter", row, column, cell, event);
+    },
+    onCellMouseLeave: (row, column, cell, event) => {
+      emit("cellMouseLeave", row, column, cell, event);
+    },
+    onCellClick: (row, column, cell, event) => {
+      emit("cellClick", row, column, cell, event);
+    },
+    onCellDblclick: (row, column, cell, event) => {
+      emit("cellDblclick", row, column, cell, event);
+    },
+    onCellContextmenu: (row, column, cell, event) => {
+      emit("cellContextmenu", row, column, cell, event);
+    },
+    onRowClick: (row, column, event) => {
+      emit("rowClick", row, column, event);
+    },
+    onRowContextmenu: (row, column, event) => {
+      emit("rowContextmenu", row, column, event);
+    },
+    onRowDblclick: (row, column, event) => {
+      emit("rowDblclick", row, column, event);
+    },
+    onHeaderClick: (column, event) => {
+      emit("headerClick", column, event);
+    },
+    onHeaderContextmenu: (column, event) => {
+      emit("headerContextmenu", column, event);
+    },
+    onHeaderDragend: (newWidth, oldWidth, column, event) => {
+      emit("headerDragend", newWidth, oldWidth, column, event);
+    },
+    onExpandChange: (row, expanded) => {
+      emit("expandChange", row, expanded);
+    },
+    onSelectionChange: (selection) => {
+      emit("selectionChange", selection);
+    },
+    onSortChange: (sorter) => {
+      emit("sortChange", sorter);
+    },
+    onFilterChange: (filter) => {
+      emit("filterChange", filter);
+    },
+    onCurrentChange: (currentRow, oldCurrentRow) => {
+      emit("currentChange", currentRow, oldCurrentRow);
+    }
+  };
+}
+export {
+  getBodyRowClass,
+  getCols,
+  getEmptyProps,
+  getEmptySlot,
+  getGlobalTooltipProps,
+  getHeadRowClass,
+  getRowClass,
+  getSelectableFunc,
+  getSlot,
+  getStateCols,
+  getTableFilter,
+  getTooltipProps,
+  getValue,
+  isDisableRow,
+  isReserveSelected,
+  mergeTooltipProps,
+  renderSlot,
+  useEmits,
+  useMethods,
+  useState
+};

package/es/ele-dot/props.d.ts

@@ -4,13 +4,18 @@ import type { DotType } from './types';
  * 属性
  */
 export declare const dotProps: {
+    /** 类型 */
     type: PropType<DotType>;
+    /** 自定义颜色 */
     color: StringConstructor;
+    /** 是否显示水波动画 */
     ripple: {
         type: BooleanConstructor;
         default: boolean;
     };
+    /** 文本 */
     text: StringConstructor;
+    /** 尺寸 */
     size: {
         type: StringConstructor;
         default: string;

package/es/ele-dot/props.js

@@ -1,16 +1,16 @@
 const dotProps = {
-  // 类型
+  /** 类型 */
   type: String,
-  // 自定义颜色
+  /** 自定义颜色 */
   color: String,
-  // 是否显示水波动画
+  /** 是否显示水波动画 */
   ripple: {
     type: Boolean,
     default: true
   },
-  // 文本
+  /** 文本 */
   text: String,
-  // 尺寸
+  /** 尺寸 */
   size: {
     type: String,
     default: "6px"

package/es/ele-drawer/index.d.ts

@@ -136,9 +136,9 @@ declare const _default: import("vue").DefineComponent<{
     title: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
     ariaLevel: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "2", boolean>;
 }>> & {
-    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
     onOpen?: (() => any) | undefined;
     onClose?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
     onOpened?: (() => any) | undefined;
     onClosed?: (() => any) | undefined;
     onOpenAutoFocus?: (() => any) | undefined;

package/es/ele-drawer/props.d.ts

@@ -3,10 +3,15 @@ import type { PropType, ExtractPropTypes } from 'vue';
  * 属性
  */
 export declare const drawerProps: {
+    /** 自定义标题样式 */
     headerStyle: PropType<Partial<import("vue").CSSProperties>>;
+    /** 标题样式 */
     titleStyle: PropType<Partial<import("vue").CSSProperties>>;
+    /** 自定义主体样式 */
     bodyStyle: PropType<Partial<import("vue").CSSProperties>>;
+    /** 自定义底部样式 */
     footerStyle: PropType<Partial<import("vue").CSSProperties>>;
+    /** 自定义关闭按钮样式 */
     closeBtnStyle: PropType<Partial<import("vue").CSSProperties>>;
     direction: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "ltr" | "rtl" | "ttb" | "btt", unknown, "rtl", boolean>;
     size: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "30%", boolean>;

package/es/ele-drawer/props.js

@@ -1,15 +1,15 @@
 import { drawerProps as drawerProps$1 } from "element-plus";
 const drawerProps = {
   ...drawerProps$1,
-  // 自定义标题样式
+  /** 自定义标题样式 */
   headerStyle: Object,
-  // 标题样式
+  /** 标题样式 */
   titleStyle: Object,
-  // 自定义主体样式
+  /** 自定义主体样式 */
   bodyStyle: Object,
-  // 自定义底部样式
+  /** 自定义底部样式 */
   footerStyle: Object,
-  // 自定义关闭按钮样式
+  /** 自定义关闭按钮样式 */
   closeBtnStyle: Object
 };
 export {

package/es/ele-drawer/style/css-var.scss

@@ -1,5 +1,6 @@
 @use '../../style/util.scss' as *;
 
+/* 抽屉主题变量 */
 @mixin set-drawer-var($var) {
   .ele-drawer {
     @include set-ele-var('drawer', $var);

package/es/ele-dropdown/index.d.ts

@@ -97,10 +97,10 @@ declare const _default: import("vue").DefineComponent<{
     teleported: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
 }>> & {
     onClick?: (() => any) | undefined;
+    onChange?: ((_active: import("element-plus/es/utils").EpPropMergeType<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown> | undefined) => any) | undefined;
     onCommand?: ((_command: import("element-plus/es/utils").EpPropMergeType<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown> | undefined) => any) | undefined;
     onVisibleChange?: ((_visible: boolean) => any) | undefined;
     "onUpdate:modelValue"?: ((_value: import("element-plus/es/utils").EpPropMergeType<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown> | undefined) => any) | undefined;
-    onChange?: ((_active: import("element-plus/es/utils").EpPropMergeType<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown> | undefined) => any) | undefined;
 }, {
     size: string;
     trigger: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "hover" | "focus" | "click" | "contextmenu" | import("element-plus").TooltipTriggerType[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").TooltipTriggerType>) | ((new (...args: any[]) => "hover" | "focus" | "click" | "contextmenu" | import("element-plus").TooltipTriggerType[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").TooltipTriggerType>))[], unknown, unknown>;