vxe-table 4.3.13 → 4.4.0-beta.0

package/types/table.d.ts

@@ -14,22 +14,24 @@ import { VxeMenuPanelInstance } from './menu'
  * 组件 - 表格
  * @example import { VxeTable } from 'vxe-table'
  */
-export const VxeTable: VXEComponent<VxeTableProps, VxeTableEventProps>
+export const VxeTable: VXEComponent<VxeTableProps<any>, VxeTableEventProps<any>>
 /**
  * 组件 - 表格
  */
-export const Table: VXEComponent<VxeTableProps, VxeTableEventProps>
+export const Table: VXEComponent<VxeTableProps<any>, VxeTableEventProps<any>>
 
-export type VxeTableInstance = ComponentPublicInstance<VxeTableProps, VxeTableConstructor>
+export type VxeTableInstance<D = any> = ComponentPublicInstance<VxeTableProps<D>, VxeTableConstructor<D>>
 
-export interface VxeTableConstructor extends VxeComponentBase, VxeTableMethods {
-  props: Readonly<VxeTableProps>
+export type VxeTableDataRow = Record<string, any>
+
+export interface VxeTableConstructor<D = any> extends VxeComponentBase, VxeTableMethods<D> {
+  props: Readonly<VxeTableProps<D>>
   context: SetupContext<VxeTableEmits>
   instance: ComponentInternalInstance
-  reactData: TableReactData
-  internalData: TableInternalData
+  reactData: TableReactData<D>
+  internalData: TableInternalData<D>
   getRefMaps(): TablePrivateRef
-  getComputeMaps(): TablePrivateComputed
+  getComputeMaps(): TablePrivateComputed<D>
   renderVN: RenderFunction
 
   xegrid: VxeGridConstructor | null
@@ -56,7 +58,7 @@ export interface TablePrivateRef {
 }
 export interface VxeTablePrivateRef extends TablePrivateRef { }
 
-export interface TablePrivateComputed {
+export interface TablePrivateComputed<D = VxeTableDataRow> {
   computeSize: ComputedRef<VxeTablePropTypes.Size>
   computeValidOpts: ComputedRef<VxeTablePropTypes.ValidOpts>
   computeSXOpts: ComputedRef<VxeTablePropTypes.SXOpts>
@@ -64,59 +66,59 @@ export interface TablePrivateComputed {
   computeColumnOpts: ComputedRef<VxeTablePropTypes.ColumnOpts>
   computeRowOpts: ComputedRef<VxeTablePropTypes.RowOpts>
   computeResizeleOpts: ComputedRef<VxeTablePropTypes.ResizeOpts>
-  computeResizableOpts: ComputedRef<VxeTablePropTypes.ResizableOpts>
-  computeSeqOpts: ComputedRef<VxeTablePropTypes.SeqOpts>
-  computeRadioOpts: ComputedRef<VxeTablePropTypes.RadioOpts>
-  computeCheckboxOpts: ComputedRef<VxeTablePropTypes.CheckboxOpts>
-  computeTooltipOpts: ComputedRef<VxeTablePropTypes.TooltipOpts>
-  computeEditOpts: ComputedRef<VxeTablePropTypes.EditOpts>
-  computeSortOpts: ComputedRef<VxeTablePropTypes.SortConfig>
-  computeFilterOpts: ComputedRef<VxeTablePropTypes.FilterOpts>
+  computeResizableOpts: ComputedRef<VxeTablePropTypes.ResizableOpts<D>>
+  computeSeqOpts: ComputedRef<VxeTablePropTypes.SeqOpts<D>>
+  computeRadioOpts: ComputedRef<VxeTablePropTypes.RadioOpts<D>>
+  computeCheckboxOpts: ComputedRef<VxeTablePropTypes.CheckboxOpts<D>>
+  computeTooltipOpts: ComputedRef<VxeTablePropTypes.TooltipOpts<D>>
+  computeEditOpts: ComputedRef<VxeTablePropTypes.EditOpts<D>>
+  computeSortOpts: ComputedRef<VxeTablePropTypes.SortConfig<D>>
+  computeFilterOpts: ComputedRef<VxeTablePropTypes.FilterOpts<D>>
   computeMouseOpts: ComputedRef<VxeTablePropTypes.MouseOpts>
   computeAreaOpts: ComputedRef<VxeTablePropTypes.AreaOpts>
   computeKeyboardOpts: ComputedRef<VxeTablePropTypes.KeyboardOpts>
-  computeClipOpts: ComputedRef<VxeTablePropTypes.ClipOpts>
-  computeFNROpts: ComputedRef<VxeTablePropTypes.FNROpts>
+  computeClipOpts: ComputedRef<VxeTablePropTypes.ClipOpts<D>>
+  computeFNROpts: ComputedRef<VxeTablePropTypes.FNROpts<D>>
   computeHeaderMenu: ComputedRef<VxeTableDefines.MenuFirstOption>
   computeBodyMenu: ComputedRef<VxeTableDefines.MenuFirstOption>
   computeFooterMenu: ComputedRef<VxeTableDefines.MenuFirstOption>
   computeIsMenu: ComputedRef<boolean>
-  computeMenuOpts: ComputedRef<VxeTablePropTypes.MenuConfig>
+  computeMenuOpts: ComputedRef<VxeTablePropTypes.MenuConfig<D>>
   computeExportOpts: ComputedRef<VxeTablePropTypes.ExportOpts>
   computeImportOpts: ComputedRef<VxeTablePropTypes.ImportOpts>
   computePrintOpts: ComputedRef<VxeTablePropTypes.PrintOpts>
-  computeExpandOpts: ComputedRef<VxeTablePropTypes.ExpandOpts>
-  computeTreeOpts: ComputedRef<VxeTablePropTypes.TreeOpts>
+  computeExpandOpts: ComputedRef<VxeTablePropTypes.ExpandOpts<D>>
+  computeTreeOpts: ComputedRef<VxeTablePropTypes.TreeOpts<D>>
   computeEmptyOpts: ComputedRef<VxeTablePropTypes.EmptyOpts>
   computeLoadingOpts: ComputedRef<VxeTablePropTypes.LoadingOpts>
-  computeCustomOpts: ComputedRef<VxeTablePropTypes.CustomOpts>
+  computeCustomOpts: ComputedRef<VxeTablePropTypes.CustomOpts<D>>
   computeIsAllCheckboxDisabled: ComputedRef<boolean>
 }
 
-export type VxeTablePrivateComputed = TablePrivateComputed
+export type VxeTablePrivateComputed<D = VxeTableDataRow> = TablePrivateComputed<D>
 
-export interface TableMethods extends TablePublicMethods {
+export interface TableMethods<D = VxeTableDataRow> extends TablePublicMethods<D> {
   dispatchEvent(type: ValueOf<VxeTableEmits>, params: any, evnt: Event | null): void
 }
 
-export interface TablePublicMethods {
+export interface TablePublicMethods<DT = VxeTableDataRow> {
   /**
    * 手动清除表格所有条件，还原到初始状态
    * 对于增删改查的场景中可能会用到，比如在数据保存之后清除表格缓存
    */
-  clearAll(): Promise<any>
+  clearAll(): Promise<void>
   /**
    * 该方法已废弃！！！
    * 同步 data 数据；如果用了该方法，那么组件将不再记录增删改的状态，只能自行实现对应逻辑
    * 对于某些特殊的场景，比如深层树节点元素发生变动时可能会用到
    * @deprecated
    */
-  syncData(): Promise<any>
+  syncData(): Promise<void>
   /**
    * 手动处理数据，用于手动排序与筛选
    * 对于手动更改了排序、筛选...等条件后需要重新处理数据时可能会用到
    */
-  updateData(): Promise<any>
+  updateData(): Promise<void>
   /**
    * 加载数据
    * @param data 数据
@@ -126,14 +128,14 @@ export interface TablePublicMethods {
    * 加载数据并恢复到初始状态
    * @param data 数据
    */
-  reloadData(data: any[]): Promise<any>
+  reloadData(data: any[]): Promise<void>
   /**
    * 局部加载行数据并恢复到初始状态
    * @param rows 行对象
    * @param record 新数据
    * @param field 指定字段名
    */
-  reloadRow(rows: any | any[], record?: any, field?: string): Promise<any>
+  reloadRow(rows: any | any[], record?: any, field?: string): Promise<void>
   /**
    * 用于树结构，给行数据加载子节点
    * @param row 行对象
@@ -144,12 +146,12 @@ export interface TablePublicMethods {
    * 加载列配置
    * @param columns 列对象
    */
-  loadColumn(columns: (VxeTableDefines.ColumnOptions | VxeTableDefines.ColumnInfo)[]): Promise<any>
+  loadColumn(columns: (VxeTableDefines.ColumnOptions<any> | VxeTableDefines.ColumnInfo<any>)[]): Promise<any>
   /**
    * 加载列配置并恢复到初始状态
    * @param columns 列对象
    */
-  reloadColumn(columns: (VxeTableDefines.ColumnOptions | VxeTableDefines.ColumnInfo)[]): Promise<any>
+  reloadColumn(columns: (VxeTableDefines.ColumnOptions<any> | VxeTableDefines.ColumnInfo<any>)[]): Promise<any>
   /**
    * 根据 tr 元素获取对应的 row 信息
    * @param tr 行节点元素
@@ -167,10 +169,10 @@ export interface TablePublicMethods {
    */
   getColumnNode(cellElem: HTMLElement): {
     colid: string
-    item: VxeTableDefines.ColumnInfo
-    items: VxeTableDefines.ColumnInfo[]
+    item: VxeTableDefines.ColumnInfo<DT>
+    items: VxeTableDefines.ColumnInfo<DT>[]
     index: number
-    parent?: VxeTableDefines.ColumnInfo
+    parent?: VxeTableDefines.ColumnInfo<DT>
   } | null
   /**
    * 根据 row 获取行的序号
@@ -196,17 +198,17 @@ export interface TablePublicMethods {
    * 根据 column 获取相对于 columns 中的索引
    * @param column 列对象
    */
-  getColumnIndex(column: VxeTableDefines.ColumnInfo): number
+  getColumnIndex(column: VxeTableDefines.ColumnInfo<any>): number
   /**
    * 根据 column 获取相对于当前表格列中的索引
    * @param column 列对象
    */
-  getVTColumnIndex(column: VxeTableDefines.ColumnInfo): number
+  getVTColumnIndex(column: VxeTableDefines.ColumnInfo<any>): number
   /**
    * 根据 column 获取渲染中的虚拟索引
    * @param column 列对象
    */
-  getVMColumnIndex(column: VxeTableDefines.ColumnInfo): number
+  getVMColumnIndex(column: VxeTableDefines.ColumnInfo<any>): number
   /**
    * 创建 data 对象
    * 对于某些特殊场景可能会用到，会自动对数据的字段名进行检测，如果不存在就自动定义
@@ -250,46 +252,46 @@ export interface TablePublicMethods {
    * 获取表格的可视列，也可以指定索引获取列
    * @param columnIndex 列索引
    */
-  getColumns(): VxeTableDefines.ColumnInfo[]
-  getColumns(columnIndex?: number): VxeTableDefines.ColumnInfo
+  getColumns(): VxeTableDefines.ColumnInfo<DT>[]
+  getColumns(columnIndex?: number): VxeTableDefines.ColumnInfo<DT>
   /**
    * 根据列的唯一主键获取列
    * @param colid 列主键
    */
-  getColumnById(colid: string): VxeTableDefines.ColumnInfo | null
+  getColumnById(colid: string): VxeTableDefines.ColumnInfo<DT> | null
   /**
    * 根据列的字段名获取列
    * @param field 字段名
    */
-  getColumnByField(field: string): VxeTableDefines.ColumnInfo | null
+  getColumnByField(field: string): VxeTableDefines.ColumnInfo<DT> | null
   /**
    * 获取当前表格的列
    * 收集到的全量列、全量表头列、处理条件之后的全量表头列、当前渲染中的表头列
    */
   getTableColumn(): {
-    collectColumn: VxeTableDefines.ColumnInfo[]
-    fullColumn: VxeTableDefines.ColumnInfo[]
-    visibleColumn: VxeTableDefines.ColumnInfo[]
-    tableColumn: VxeTableDefines.ColumnInfo[]
+    collectColumn: VxeTableDefines.ColumnInfo<DT>[]
+    fullColumn: VxeTableDefines.ColumnInfo<DT>[]
+    visibleColumn: VxeTableDefines.ColumnInfo<DT>[]
+    tableColumn: VxeTableDefines.ColumnInfo<DT>[]
   }
   /**
    * 获取数据，和 data 的行为一致，也可以指定索引获取数据
    */
-  getData(): any[]
-  getData(rowIndex: number): any
+  getData(): DT[]
+  getData(rowIndex: number): DT
   /**
    * 用于 type=checkbox，获取已选中的行数据
    */
-  getCheckboxRecords(isFull?: boolean): any[]
+  getCheckboxRecords(isFull?: boolean): DT[]
   /**
    * 只对 tree-config 有效，获取行的父级
    */
-  getParentRow (rowOrRowid: any): any | null
+  getParentRow(rowOrRowid: any): DT | null
   /**
    * 根据行的唯一主键获取行
    * @param rowid 行主键
    */
-  getRowById(rowid: string | number): any | null
+  getRowById(rowid: string | number): DT | null
   /**
    * 根据行获取行的唯一主键
    * @param row 行对象
@@ -300,53 +302,53 @@ export interface TablePublicMethods {
    * 完整的全量表体数据、处理条件之后的全量表体数据、当前渲染中的表体数据、当前渲染中的表尾数据
    */
   getTableData(): {
-    fullData: any[]
-    visibleData: any[]
-    tableData: any[]
-    footerData: any[][]
+    fullData: DT[]
+    visibleData: DT[]
+    tableData: DT[]
+    footerData: DT[][]
   }
   /**
    * 隐藏指定列
    * @param columnOrField 列对象或字段名
    */
-  hideColumn(fieldOrColumn: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo): Promise<any>
+  hideColumn(fieldOrColumn: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo<any>): Promise<void>
   /**
    * 显示指定列
    * @param columnOrField 列对象或字段名
    */
-  showColumn(fieldOrColumn: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo): Promise<any>
+  showColumn(fieldOrColumn: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo<any>): Promise<void>
   /**
    * 设置列宽
    * @param fieldOrColumn 列对象或字段名
    * @param width 宽度 %，px
    */
-  setColumnWidth(fieldOrColumn: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo, width: number | string): Promise<any>
+  setColumnWidth(fieldOrColumn: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo<any>, width: number | string): Promise<void>
   /**
    * 获取列宽
    * @param fieldOrColumn 列对象或字段名
    */
-  getColumnWidth(fieldOrColumn: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo): number;
+  getColumnWidth(fieldOrColumn: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo<any>): number;
   /**
    * 手动重置列的显示隐藏、列宽拖动的状态；如果为 true 则重置所有状态
    * 如果已关联工具栏，则会同步更新
    * @param options 可选参数
    */
-  resetColumn(options?: boolean | { visible?: boolean, resizable?: boolean }): Promise<any>
+  resetColumn(options?: boolean | { visible?: boolean, resizable?: boolean }): Promise<void>
   /**
    * 刷新列配置
    * 对于动态修改属性、显示/隐藏列等场景下可能会用到
    */
-  refreshColumn(): Promise<any>
+  refreshColumn(): Promise<void>
   /**
    * 刷新滚动操作，手动同步滚动相关位置
    * 对于某些特殊的操作，比如滚动条错位、固定列不同步
    */
-  refreshScroll(): Promise<any>
+  refreshScroll(): Promise<void>
   /**
    * 重新计算表格，如果传 true 则进行完整计算
    * 对于某些特殊场景可能会用到，比如隐藏的表格、重新计算列宽...等
    */
-  recalculate(refull?: boolean): Promise<any>
+  recalculate(refull?: boolean): Promise<void>
   /**
    * 打开 tooltip 提示
    * @param target 目标元素
@@ -461,7 +463,7 @@ export interface TablePublicMethods {
   /**
    * 用于 column-config.isCurrent，获取当前列
    */
-  getCurrentColumn(): VxeTableDefines.ColumnInfo | null
+  getCurrentColumn(): VxeTableDefines.ColumnInfo<DT> | null
   /**
    * 用于 row-config.isCurrent，获取当前行的行数据
    */
@@ -474,7 +476,7 @@ export interface TablePublicMethods {
    * 用于 column-config.isCurrent，设置某列行为高亮状态
    * @param columnOrField 列对象或字段名
    */
-  setCurrentColumn(fieldOrColumn: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo): Promise<any>
+  setCurrentColumn(fieldOrColumn: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo<any>): Promise<any>
   /**
    * 用于 column-config.isCurrent，手动清空当前高亮的状态
    */
@@ -491,12 +493,12 @@ export interface TablePublicMethods {
    * 手动清空排序条件，数据会恢复成未排序的状态
    * @param columnOrField 列对象或字段名
    */
-  clearSort(fieldOrColumn?: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | null): Promise<any>
+  clearSort(fieldOrColumn?: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo<any> | null): Promise<any>
   /**
    * 判断指定列是否为排序状态，如果为空则判断所有列
    * @param columnOrField 列对象或字段名
    */
-  isSort(fieldOrColumn: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo): boolean
+  isSort(fieldOrColumn: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo<any>): boolean
   /**
    * 获取当前排序的列信息
    */
@@ -505,11 +507,16 @@ export interface TablePublicMethods {
    * 手动关闭筛选面板
    */
   closeFilter(): Promise<any>
+  /**
+   * 已废弃，请使用 isActiveFilterByColumn
+   * @deprecated
+   */
+  isFilter(fieldOrColumn: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo<any>): boolean
   /**
    * 判断指定列是否为筛选状态，如果为空则判断所有列
    * @param columnOrField 列对象或字段名
    */
-  isFilter(fieldOrColumn: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo): boolean
+  isActiveFilterByColumn(fieldOrColumn: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo<any>): boolean
   /**
    * 用于 expand-config.lazy，用于懒加载展开行，判断展开行是否懒加载完成
    * @param row 指定行
@@ -518,33 +525,33 @@ export interface TablePublicMethods {
   /**
    * 用于 expand-config.lazy，手动清空懒加载展开行的状态，数据会恢复成未展开的状态，当再次展开时会重新加载
    */
-  clearRowExpandLoaded(row: any): Promise<any>
+  clearRowExpandLoaded(row: any): Promise<void>
   /**
    * 重新懒加载展开行，并展开内容
    * @param row 指定行
    */
-  reloadRowExpand(row: any): Promise<any>
+  reloadRowExpand(row: any): Promise<void>
   /**
    * @deprecated 已废弃，请使用 reloadRowExpand
    */
-  reloadExpandContent(row: any): Promise<any>
+  reloadExpandContent(row: any): Promise<void>
   /**
    * 用于 type=expand，切换展开行的状态
    * @param row 指定行
    */
-  toggleRowExpand(row: any): Promise<any>
+  toggleRowExpand(row: any): Promise<void>
   /**
    * 用于 expand-config，设置所有行的展开与否
    * 如果是关闭所有行，可以使用 clearRowExpand 快速清除
    * @param checked 是否选中
    */
-  setAllRowExpand(checked: boolean): Promise<any>
+  setAllRowExpand(checked: boolean): Promise<void>
   /**
    * 用于 expand-config，设置展开行，二个参数设置这一行展开与否
    * @param rows 指定行
    * @param checked 是否选中
    */
-  setRowExpand(rows: any | any[], checked: boolean): Promise<any>
+  setRowExpand(rows: any | any[], checked: boolean): Promise<void>
   /**
    * 用于 expand-config，判断行是否为展开状态
    * @param row 指定行
@@ -553,20 +560,20 @@ export interface TablePublicMethods {
   /**
    * 用于 type=expand，手动清空展开行状态，数据会恢复成未展开的状态
    */
-  clearRowExpand(): Promise<any>
+  clearRowExpand(): Promise<void>
   /**
    * 用于 type=expand，手动清空用户保留行的展开状态
    */
-  clearRowExpandReserve(): Promise<any>
+  clearRowExpandReserve(): Promise<void>
   /**
    * 用于 expand-config，用于展开行，获取已展开的行数据
    */
-  getRowExpandRecords(): any[]
+  getRowExpandRecords(): DT[]
   /**
    * 用于 tree-config，用于树表格，获取已展开的节点
    * 注意，即使父节点被收起，只要该节点还处于展开状态都能获取到
    */
-  getTreeExpandRecords(): any[]
+  getTreeExpandRecords(): DT[]
   /**
    * 用于 tree-config.lazy，用于懒加载树表格，判断树节点是否懒加载完成
    */
@@ -594,13 +601,13 @@ export interface TablePublicMethods {
    * 如果是关闭所有树节点，可以使用 clearTreeExpand 快速清除
    * @param checked 是否选中
    */
-  setAllTreeExpand(checked: boolean): Promise<any>
+  setAllTreeExpand(checked: boolean): Promise<void>
   /**
    * 用于 tree-config，设置展开树形节点，二个参数设置这一行展开与否
    * @param rows 指定行
    * @param checked 是否选中
    */
-  setTreeExpand(rows: any | any[], checked: boolean): Promise<any>
+  setTreeExpand(rows: any | any[], checked: boolean): Promise<void>
   /**
    * 用于 tree-config，判断行是否为树形节点展开状态
    * @param row 指定行
@@ -609,11 +616,11 @@ export interface TablePublicMethods {
   /**
    * 用于 tree-config，手动清空树形节点的展开状态，数据会恢复成未展开的状态
    */
-  clearTreeExpand(): Promise<any>
+  clearTreeExpand(): Promise<void>
   /**
    * 用于 tree-config.reserve，手动清空用户保留树节点的展开状态
    */
-  clearTreeExpandReserve(): Promise<any>
+  clearTreeExpandReserve(): Promise<void>
   /**
    * 获取表格的滚动状态
    */
@@ -634,12 +641,12 @@ export interface TablePublicMethods {
    * @param row 指定行
    * @param columnOrField 列对象或字段名
    */
-  scrollToRow(row: any, fieldOrColumn?: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo): Promise<any>
+  scrollToRow(row: any, fieldOrColumn?: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo<any>): Promise<any>
   /**
    * 如果有滚动条，则滚动到对应的列
    * @param columnOrField 列对象或字段名
    */
-  scrollToColumn(fieldOrColumn: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo): Promise<any>
+  scrollToColumn(fieldOrColumn: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo<any>): Promise<any>
   /**
    * 手动清除滚动相关信息，还原到初始状态
    */
@@ -654,27 +661,27 @@ export interface TablePublicMethods {
    */
   updateStatus(
     params: {
-      row: any
-      column: VxeTableDefines.ColumnInfo
+      row: DT
+      column: VxeTableDefines.ColumnInfo<DT>
     },
     cellValue?: any
   ): Promise<any>
   /**
    * 取消单元格的临时合并状态，如果为数组，则取消多个合并
    */
-  removeMergeCells(merges: VxeTableDefines.MergeOptions | VxeTableDefines.MergeOptions[]): Promise<VxeTableDefines.MergeInfo[]>
+  removeMergeCells(merges: VxeTableDefines.MergeOptions<any> | VxeTableDefines.MergeOptions<any>[]): Promise<VxeTableDefines.MergeInfo[]>
   /**
    * 取消表尾的临时合并状态，如果为数组，则取消多个合并
    */
-  removeMergeFooterItems(merges: VxeTableDefines.MergeOptions | VxeTableDefines.MergeOptions[]): Promise<VxeTableDefines.MergeInfo[]>
+  removeMergeFooterItems(merges: VxeTableDefines.MergeOptions<any> | VxeTableDefines.MergeOptions<any>[]): Promise<VxeTableDefines.MergeInfo[]>
   /**
    * 临时合并单元格，如果为数组则合并多个
    */
-  setMergeCells(merges: VxeTableDefines.MergeOptions | VxeTableDefines.MergeOptions[]): Promise<any>
+  setMergeCells(merges: VxeTableDefines.MergeOptions<any> | VxeTableDefines.MergeOptions<any>[]): Promise<any>
   /**
    * 临时合并表尾，如果为数组则合并多个
    */
-  setMergeFooterItems(merges: VxeTableDefines.MergeOptions | VxeTableDefines.MergeOptions[]): Promise<any>
+  setMergeFooterItems(merges: VxeTableDefines.MergeOptions<any> | VxeTableDefines.MergeOptions<any>[]): Promise<any>
   /**
    * 用于 mouse-config.area，更新已选区域的单元格样式
    */
@@ -683,20 +690,20 @@ export interface TablePublicMethods {
    * 连接工具栏
    * @param toolbar 工具栏组件实例
    */
-  connect(toolbar: VxeToolbarConstructor | VxeToolbarInstance): Promise<any>
+  connect(toolbar: VxeToolbarConstructor | VxeToolbarInstance): Promise<void>
   /**
    * 使表格获取焦点
    */
-  focus(): Promise<any>
+  focus(): Promise<void>
   /**
    * 使表格失去焦点
    */
-  blur(): Promise<any>
+  blur(): Promise<void>
 }
 
-export interface VxeTableMethods extends TableMethods { }
+export interface VxeTableMethods<D = VxeTableDataRow> extends TableMethods<D> { }
 
-export interface TablePrivateMethods {
+export interface TablePrivateMethods<D = VxeTableDataRow> {
   getSetupOptions(): VXETableSetupOptions
   updateAfterDataIndex(): void
   callSlot<T>(slotFunc: ((params: T) => SlotVNodeType | SlotVNodeType[]) | string | null, params: T): SlotVNodeType[]
@@ -711,30 +718,30 @@ export interface TablePrivateMethods {
   analyColumnWidth(): void
   checkSelectionStatus(): void
   handleSelectRow(params: any, value: any, isForce?: boolean): void
-  handleCustom(): Promise<any>
+  handleCustom(): Promise<void>
   preventEvent(evnt: any, type: any, args?: any, next?: any, end?: any): any
-  triggerHeaderHelpEvent(evnt: MouseEvent, params: VxeTableDefines.CellRenderHeaderParams): void
-  triggerHeaderTooltipEvent(evnt: MouseEvent, params: VxeTableDefines.CellRenderHeaderParams): void
-  triggerBodyTooltipEvent(evnt: MouseEvent, params: VxeTableDefines.CellRenderBodyParams): void
-  triggerFooterTooltipEvent(evnt: MouseEvent, params: VxeTableDefines.CellRenderFooterParams): void
+  triggerHeaderHelpEvent(evnt: MouseEvent, params: VxeTableDefines.CellRenderHeaderParams<any>): void
+  triggerHeaderTooltipEvent(evnt: MouseEvent, params: VxeTableDefines.CellRenderHeaderParams<any>): void
+  triggerBodyTooltipEvent(evnt: MouseEvent, params: VxeTableDefines.CellRenderBodyParams<any>): void
+  triggerFooterTooltipEvent(evnt: MouseEvent, params: VxeTableDefines.CellRenderFooterParams<any>): void
   handleTargetLeaveEvent(evnt: MouseEvent): void
-  triggerHeaderCellClickEvent(evnt: MouseEvent, params: VxeTableDefines.CellRenderHeaderParams): void
-  triggerHeaderCellDblclickEvent(evnt: MouseEvent, params: VxeTableDefines.CellRenderHeaderParams): void
-  triggerCellClickEvent(evnt: MouseEvent, params: VxeTableDefines.CellRenderBodyParams): void
-  triggerCellDblclickEvent(evnt: MouseEvent, params: VxeTableDefines.CellRenderBodyParams): void
+  triggerHeaderCellClickEvent(evnt: MouseEvent, params: VxeTableDefines.CellRenderHeaderParams<any>): void
+  triggerHeaderCellDblclickEvent(evnt: MouseEvent, params: VxeTableDefines.CellRenderHeaderParams<any>): void
+  triggerCellClickEvent(evnt: MouseEvent, params: VxeTableDefines.CellRenderBodyParams<any>): void
+  triggerCellDblclickEvent(evnt: MouseEvent, params: VxeTableDefines.CellRenderBodyParams<any>): void
   handleToggleCheckRowEvent(evnt: Event | null, params: { row: any }): void
   triggerCheckRowEvent(evnt: Event, params: { row: any }, value: boolean): void
   triggerCheckAllEvent(evnt: MouseEvent | null, value: boolean): void
   triggerRadioRowEvent(evnt: Event, params: { row: any }): void
   triggerCurrentRowEvent(evnt: Event, params: {
-    $table: VxeTableConstructor & VxeTablePrivateMethods
+    $table: VxeTableConstructor<any> & VxeTablePrivateMethods<any>
     row: any
     rowIndex: number
     $rowIndex: number
   }): void
-  triggerRowExpandEvent(evnt: Event, params: VxeTableDefines.CellRenderBodyParams): void
-  triggerTreeExpandEvent(evnt: Event, params: VxeTableDefines.CellRenderBodyParams): void
-  triggerSortEvent(evnt: Event, column: VxeTableDefines.ColumnInfo, order: VxeTablePropTypes.SortOrder): void
+  triggerRowExpandEvent(evnt: Event, params: VxeTableDefines.CellRenderBodyParams<any>): void
+  triggerTreeExpandEvent(evnt: Event, params: VxeTableDefines.CellRenderBodyParams<any>): void
+  triggerSortEvent(evnt: Event, column: VxeTableDefines.ColumnInfo<any>, order: VxeTablePropTypes.SortOrder): void
   triggerScrollXEvent(evnt: Event): void
   triggerScrollYEvent(evnt: Event): void
   scrollToTreeRow(row: any): Promise<any>
@@ -749,15 +756,15 @@ export interface TablePrivateMethods {
   triggerHoverEvent(evnt: any, params: any): void
   setHoverRow(row: any): void
   clearHoverRow(): void
-  getCell(row: any, column: VxeTableDefines.ColumnInfo): HTMLTableDataCellElement | null
-  getCellLabel(row: any, column: VxeTableDefines.ColumnInfo): any
+  getCell(row: any, column: VxeTableDefines.ColumnInfo<any>): HTMLTableDataCellElement | null
+  getCellLabel(row: any, column: VxeTableDefines.ColumnInfo<any>): any
   findRowIndexOf(list: any[], row: any): number
   eqRow(row1: any, row2: any): boolean
 }
 
-export interface VxeTablePrivateMethods extends TablePrivateMethods { }
+export interface VxeTablePrivateMethods<D = VxeTableDataRow> extends TablePrivateMethods<D> { }
 
-export interface TableReactData {
+export interface TableReactData<D = VxeTableDataRow> {
   // 低性能的静态列
   staticColumns: any[]
   // 渲染的列分组
@@ -765,7 +772,7 @@ export interface TableReactData {
   // 可视区渲染的列
   tableColumn: any[]
   // 渲染中的数据
-  tableData: any[]
+  tableData: D[]
   // 是否启用了横向 X 可视渲染方式加载
   scrollXLoad: boolean
   // 是否启用了纵向 Y 可视渲染方式加载
@@ -790,13 +797,13 @@ export interface TableReactData {
   // 复选框属性，有选中且非全选状态
   isIndeterminate: boolean
   // 复选框属性，已选中的行
-  selection: any[]
+  selection: D[]
   // 当前行
-  currentRow: any
+  currentRow: D | null
   // 单选框属性，选中列
   currentColumn: any
   // 单选框属性，选中行
-  selectRow: any
+  selectRow: D | null
   // 表尾合计数据
   footerTableData: any[][]
   // 展开列信息
@@ -805,19 +812,19 @@ export interface TableReactData {
   // 树节点列信息
   treeNodeColumn: any
   // 已展开的行
-  rowExpandeds: any[]
+  rowExpandeds: D[]
   // 懒加载中的展开行的列表
-  expandLazyLoadeds: any[]
+  expandLazyLoadeds: D[]
   // 已展开树节点
-  treeExpandeds: any[]
+  treeExpandeds: D[]
   // 懒加载中的树节点的列表
-  treeLazyLoadeds: any[]
+  treeLazyLoadeds: D[]
   // 树节点不确定状态的列表
-  treeIndeterminates: any[]
+  treeIndeterminates: D[]
   // 合并单元格的对象集
-  mergeList: VxeTableDefines.MergeItem[]
+  mergeList: VxeTableDefines.MergeItem<D>[]
   // 合并表尾数据的对象集
-  mergeFooterList: VxeTableDefines.MergeItem[]
+  mergeFooterList: VxeTableDefines.MergeItem<D>[]
   // 初始化标识
   initStore: {
     filter: boolean
@@ -838,15 +845,15 @@ export interface TableReactData {
   },
   // 存放列相关的信息
   columnStore: {
-    leftList: VxeTableDefines.ColumnInfo[]
-    centerList: VxeTableDefines.ColumnInfo[]
-    rightList: VxeTableDefines.ColumnInfo[]
-    resizeList: VxeTableDefines.ColumnInfo[]
-    pxList: VxeTableDefines.ColumnInfo[]
-    pxMinList: VxeTableDefines.ColumnInfo[]
-    scaleList: VxeTableDefines.ColumnInfo[]
-    scaleMinList: VxeTableDefines.ColumnInfo[]
-    autoList: VxeTableDefines.ColumnInfo[]
+    leftList: VxeTableDefines.ColumnInfo<D>[]
+    centerList: VxeTableDefines.ColumnInfo<D>[]
+    rightList: VxeTableDefines.ColumnInfo<D>[]
+    resizeList: VxeTableDefines.ColumnInfo<D>[]
+    pxList: VxeTableDefines.ColumnInfo<D>[]
+    pxMinList: VxeTableDefines.ColumnInfo<D>[]
+    scaleList: VxeTableDefines.ColumnInfo<D>[]
+    scaleMinList: VxeTableDefines.ColumnInfo<D>[]
+    autoList: VxeTableDefines.ColumnInfo<D>[]
   },
   // 存放快捷菜单的信息
   ctxMenuStore: {
@@ -868,35 +875,35 @@ export interface TableReactData {
     },
     // 选中源
     selected: {
-      row: any
+      row: D | null
       column: any
       [key: string]: any
     },
     // 已复制源
     copyed: {
       cut: boolean
-      rows: any[]
+      rows: D[]
       columns: any[]
       [key: string]: any
     },
     // 激活
     actived: {
-      row: any
+      row: D | null
       column: any
       [key: string]: any
     },
-    insertList: any[]
+    insertList: D[]
     insertMaps: {
       [key: string]: any
     }
-    removeList: any[]
+    removeList: D[]
     removeMaps: {
       [key: string]: any
     }
   },
   // 存放 tooltip 相关信息
   tooltipStore: {
-    row: any
+    row: D | null
     column: any
     content: any
     visible: boolean,
@@ -905,7 +912,7 @@ export interface TableReactData {
   // 存放数据校验相关信息
   validStore: {
     visible: boolean
-    row: any
+    row: D | null
     column: any
     content: any
     rule: any
@@ -956,7 +963,7 @@ export interface TableReactData {
   }
 }
 
-export interface TableInternalData {
+export interface TableInternalData<D = VxeTableDataRow> {
   tZindex: number
   elemStore: {
     [key: string]: Ref<HTMLElement> | null
@@ -1002,23 +1009,23 @@ export interface TableInternalData {
   // 树结构数据，已展开保留的行
   treeExpandedReserveRowMap: any
   // 列表完整数据、条件处理后
-  tableFullData: any[]
-  afterFullData: any[]
-  tableSynchData: any[]
-  tableSourceData: any[]
+  tableFullData: D[]
+  afterFullData: D[]
+  tableSynchData: D[]
+  tableSourceData: D[]
   // 树的全量数据、条件处理后
-  tableFullTreeData: any[]
-  afterTreeFullData: any[]
+  tableFullTreeData: D[]
+  afterTreeFullData: D[]
   // 收集的列配置（带分组）
-  collectColumn: VxeTableDefines.ColumnInfo[],
+  collectColumn: VxeTableDefines.ColumnInfo<D>[],
   // 完整所有列（不带分组）
-  tableFullColumn: VxeTableDefines.ColumnInfo[]
+  tableFullColumn: VxeTableDefines.ColumnInfo<D>[]
   // 渲染所有列
-  visibleColumn: VxeTableDefines.ColumnInfo[]
+  visibleColumn: VxeTableDefines.ColumnInfo<D>[]
   // 缓存数据集
   fullAllDataRowIdData: {
     [key: string]: {
-      row: any
+      row: D
       rowid: string
       seq: string | number
       index: number
@@ -1039,7 +1046,7 @@ export interface TableInternalData {
   }
   fullDataRowIdData: {
     [key: string]: {
-      row: any
+      row: D
       rowid: string
       seq: string | number
       index: number
@@ -1052,22 +1059,22 @@ export interface TableInternalData {
   }
   fullColumnIdData: {
     [key: string]: {
-      column: VxeTableDefines.ColumnInfo
+      column: VxeTableDefines.ColumnInfo<D>
       colid: string
       index: number
       $index: number
       _index: number
-      items: VxeTableDefines.ColumnInfo[]
-      parent: VxeTableDefines.ColumnInfo
+      items: VxeTableDefines.ColumnInfo<D>[]
+      parent: VxeTableDefines.ColumnInfo<D>
     }
   }
   fullColumnFieldData: {
     [key: string]: {
-      column: VxeTableDefines.ColumnInfo
+      column: VxeTableDefines.ColumnInfo<D>
       colid: string
       index: number
-      items: VxeTableDefines.ColumnInfo[]
-      parent: VxeTableDefines.ColumnInfo
+      items: VxeTableDefines.ColumnInfo<D>[]
+      parent: VxeTableDefines.ColumnInfo<D>
     }
   }
 
@@ -1110,141 +1117,147 @@ export namespace VxeTablePropTypes {
   export type HighlightCell = boolean
   export type ShowFooter = boolean
 
-  export type FooterMethod = (params: {
-    $table: VxeTableConstructor & VxeTablePrivateMethods
-    $grid: VxeGridConstructor | null | undefined
-    columns: VxeTableDefines.ColumnInfo[]
-    data: any[]
+  export type FooterMethod<D = VxeTableDataRow> = (params: {
+    $table: VxeTableConstructor<D> & VxeTablePrivateMethods<D>
+    $grid: VxeGridConstructor<D> | null | undefined
+    columns: VxeTableDefines.ColumnInfo<D>[]
+    data: D[]
   }) => Array<string | number | null>[]
 
-  export type RowClassName = string | ((params: {
-    row: any
+  export type RowClassName<D = VxeTableDataRow> = string | ((params: {
+    $table: VxeTableConstructor<D> & VxeTablePrivateMethods<D>
+    row: D
     rowIndex: number
     $rowIndex: number
     _rowIndex: number
   }) => void | null | string | { [key: string]: boolean })
 
-  export type CellClassName = string | ((params: {
-    row: any
+  export type CellClassName<D = VxeTableDataRow> = string | ((params: {
+    $table: VxeTableConstructor<D> & VxeTablePrivateMethods<D>
+    row: D
     rowIndex: number
     $rowIndex: number
     _rowIndex: number
-    column: VxeTableDefines.ColumnInfo
+    column: VxeTableDefines.ColumnInfo<D>
     columnIndex: number
     $columnIndex: number
     _columnIndex: number
   }) => void | null | string | { [key: string]: boolean })
 
-  export type HeaderRowClassName = string | ((params: {
-    $table: VxeTableConstructor & VxeTablePrivateMethods
+  export type HeaderRowClassName<D = VxeTableDataRow> = string | ((params: {
+    $table: VxeTableConstructor<D> & VxeTablePrivateMethods<D>
     $rowIndex: number
     fixed: VxeColumnPropTypes.Fixed
     type: string
   }) => void | null | string | { [key: string]: boolean })
 
-  export type HeaderCellClassName = string | ((params: {
-    $table: VxeTableConstructor & VxeTablePrivateMethods
+  export type HeaderCellClassName<D = VxeTableDataRow> = string | ((params: {
+    $table: VxeTableConstructor<D> & VxeTablePrivateMethods<D>
     $rowIndex: number
-    column: VxeTableDefines.ColumnInfo
+    column: VxeTableDefines.ColumnInfo<D>
     fixed: VxeColumnPropTypes.Fixed
     type: string
   }) => void | null | string | { [key: string]: boolean })
 
-  export type FooterRowClassName = string | ((params: {
-    $table: VxeTableConstructor & VxeTablePrivateMethods
+  export type FooterRowClassName<D = VxeTableDataRow> = string | ((params: {
+    $table: VxeTableConstructor<D> & VxeTablePrivateMethods<D>
     $rowIndex: number
     _rowIndex: number
     fixed: VxeColumnPropTypes.Fixed
     type: string
   }) => void | null | string | { [key: string]: boolean })
 
-  export type FooterCellClassName = string | ((params: {
-    $table: VxeTableConstructor & VxeTablePrivateMethods
+  export type FooterCellClassName<D = VxeTableDataRow> = string | ((params: {
+    $table: VxeTableConstructor<D> & VxeTablePrivateMethods<D>
     $rowIndex: number
     _rowIndex: number
-    column: VxeTableDefines.ColumnInfo
+    column: VxeTableDefines.ColumnInfo<D>
     columnIndex: number
     $columnIndex: number
     _columnIndex: number
   }) => void | null | string | { [key: string]: boolean })
 
-  export type CellStyle = VNodeStyle | ((params: {
-    row: any
+  export type CellStyle<D = VxeTableDataRow> = VNodeStyle | ((params: {
+    row: D
     rowIndex: number
     $rowIndex: number
     _rowIndex: number
-    column: VxeTableDefines.ColumnInfo
+    column: VxeTableDefines.ColumnInfo<D>
     columnIndex: number
     $columnIndex: number
     _columnIndex: number
   }) => void | null | VNodeStyle)
 
-  export type HeaderCellStyle = VNodeStyle | ((params: {
-    $table: VxeTableConstructor & VxeTablePrivateMethods
+  export type HeaderCellStyle<D = VxeTableDataRow> = VNodeStyle | ((params: {
+    $table: VxeTableConstructor<D> & VxeTablePrivateMethods<D>
     $rowIndex: number
-    column: VxeTableDefines.ColumnInfo
+    column: VxeTableDefines.ColumnInfo<D>
     columnIndex: number
     _columnIndex: number
   }) => void | null | VNodeStyle)
 
-  export type FooterCellStyle = VNodeStyle | ((params: {
+  export type FooterCellStyle<D = VxeTableDataRow> = VNodeStyle | ((params: {
+    $table: VxeTableConstructor<D> & VxeTablePrivateMethods<D>
     $rowIndex: number
-    column: VxeTableDefines.ColumnInfo
+    column: VxeTableDefines.ColumnInfo<D>
     columnIndex: number
     $columnIndex: number
     _columnIndex: number
   }) => void | null | VNodeStyle)
 
-  export type RowStyle = VNodeStyle | ((params: {
-    row: any
+  export type RowStyle<D = VxeTableDataRow> = VNodeStyle | ((params: {
+    $table: VxeTableConstructor<D> & VxeTablePrivateMethods<D>
+    row: D
     rowIndex: number
     $rowIndex: number
     _rowIndex: number
   }) => void | null | VNodeStyle)
 
-  export type HeaderRowStyle = VNodeStyle | ((params: {
-    $table: VxeTableConstructor & VxeTablePrivateMethods
+  export type HeaderRowStyle<D = VxeTableDataRow> = VNodeStyle | ((params: {
+    $table: VxeTableConstructor<D> & VxeTablePrivateMethods<D>
     $rowIndex: number
     fixed: VxeColumnPropTypes.Fixed
     type: string
   }) => void | null | VNodeStyle)
 
-  export type FooterRowStyle = VNodeStyle | ((params: {
-    $table: VxeTableConstructor & VxeTablePrivateMethods
+  export type FooterRowStyle<D = VxeTableDataRow> = VNodeStyle | ((params: {
+    $table: VxeTableConstructor<D> & VxeTablePrivateMethods<D>
     $rowIndex: number
     _rowIndex: number
     fixed: VxeColumnPropTypes.Fixed
     type: string
   }) => void | null | VNodeStyle)
 
-  export type MergeCell = VxeTableDefines.MergeOptions
-  export type MergeCells = MergeCell[]
-  export type MergeFooterItem = VxeTableDefines.MergeOptions
-  export type MergeFooterItems = MergeFooterItem[]
+  export type MergeCell<D = VxeTableDataRow> = VxeTableDefines.MergeOptions<D>
+  export type MergeCells<D = VxeTableDataRow> = MergeCell<D>[]
+  export type MergeFooterItem<D = VxeTableDataRow> = VxeTableDefines.MergeOptions<D>
+  export type MergeFooterItems<D = VxeTableDataRow> = MergeFooterItem<D>[]
 
-  export type SpanMethod = (params: {
-    column: VxeTableDefines.ColumnInfo
+  export type SpanMethod<D = VxeTableDataRow> = (params: {
+    $table: VxeTableConstructor<D> & VxeTablePrivateMethods<D>
+    column: VxeTableDefines.ColumnInfo<D>
     columnIndex: number
     $columnIndex: number
-    row: any
+    row: D
     rowIndex: number
     $rowIndex: number
     _rowIndex: number
     isHidden: boolean
     fixed: VxeColumnPropTypes.Fixed
     type: string
-    visibleData: any[]
+    visibleData: D[]
   }) => void | { rowspan: number, colspan: number }
 
-  export type FooterSpanMethod = (params: {
-    column: VxeTableDefines.ColumnInfo
+  export type FooterSpanMethod<D = VxeTableDataRow> = (params: {
+    $table: VxeTableConstructor<D> & VxeTablePrivateMethods<D>
+    column: VxeTableDefines.ColumnInfo<D>
     columnIndex: number
     _columnIndex: number
     $columnIndex: number
     $rowIndex: number
     _rowIndex: number
     items: any[]
-    data: any[][]
+    data: D[][]
   }) => void | { rowspan: number, colspan: number }
 
   export type ShowOverflow = boolean | 'ellipsis' | 'title' | 'tooltip' | '' | null
@@ -1294,53 +1307,55 @@ export namespace VxeTablePropTypes {
   /**
    * 自定义列配置项
    */
-  export interface CustomConfig {
+  export interface CustomConfig<D = VxeTableDataRow> {
     storage?: boolean | {
       visible?: boolean
       resizable?: boolean
     }
-    checkMethod?(params: { column: VxeTableDefines.ColumnInfo }): boolean
+    checkMethod?(params: {
+      column: VxeTableDefines.ColumnInfo<D>
+    }): boolean
   }
-  export interface CustomOpts extends CustomConfig { }
+  export interface CustomOpts<D = VxeTableDataRow> extends CustomConfig<D> { }
 
   /**
    * 列调整配置项
    */
-  export interface ResizableConfig {
+  export interface ResizableConfig<D = VxeTableDataRow> {
     minWidth?: number | string | ((params: {
-      $table: VxeTableConstructor & VxeTablePrivateMethods
-      column: VxeTableDefines.ColumnInfo
+      $table: VxeTableConstructor<D> & VxeTablePrivateMethods<D>
+      column: VxeTableDefines.ColumnInfo<D>
       columnIndex: number
       $columnIndex: number
       $rowIndex: number
       cell: HTMLElement
     }) => number | string)
     maxWidth?: number | string | ((params: {
-      $table: VxeTableConstructor & VxeTablePrivateMethods
-      column: VxeTableDefines.ColumnInfo
+      $table: VxeTableConstructor<D> & VxeTablePrivateMethods<D>
+      column: VxeTableDefines.ColumnInfo<D>
       columnIndex: number
       $columnIndex: number
       $rowIndex: number
       cell: HTMLElement
     }) => number | string)
   }
-  export interface ResizableOpts extends ResizableConfig { }
+  export interface ResizableOpts<D = VxeTableDataRow> extends ResizableConfig<D> { }
 
   /**
    * 序号配置项
    */
-  export interface SeqConfig {
+  export interface SeqConfig<D = VxeTableDataRow> {
     startIndex?: number
     seqMethod?(params: {
-      column: VxeTableDefines.ColumnInfo
+      column: VxeTableDefines.ColumnInfo<D>
       columnIndex: number
       $columnIndex: number
-      row: any
+      row: D
       rowIndex: number
       $rowIndex: number
     }): number | string
   }
-  export interface SeqOpts extends SeqConfig { }
+  export interface SeqOpts<D = VxeTableDataRow> extends SeqConfig<D> { }
 
   interface SortConfigDefaultSort {
     field: string
@@ -1350,12 +1365,12 @@ export namespace VxeTablePropTypes {
   /**
    * 排序配置项
    */
-  export interface SortConfig {
+  export interface SortConfig<D = VxeTableDataRow> {
     defaultSort?: SortConfigDefaultSort | SortConfigDefaultSort[]
     orders?: SortOrder[]
     sortMethod?(params: {
-      $table: VxeTableConstructor & VxeTablePrivateMethods
-      data: any[]
+      $table: VxeTableConstructor<D> & VxeTablePrivateMethods<D>
+      data: D[]
       sortList: VxeTableDefines.SortCheckedParams[]
     }): any[]
     remote?: boolean
@@ -1367,51 +1382,51 @@ export namespace VxeTablePropTypes {
     iconDesc?: string
   }
   export type SortOrder = 'asc' | 'desc' | '' | null
-  export interface SortOpts extends SortConfig {
+  export interface SortOpts<D = VxeTableDataRow> extends SortConfig<D> {
     orders: SortOrder[]
   }
 
   /**
    * 筛选配置项
    */
-  export interface FilterConfig {
-    filterMethod?: (params: {
+  export interface FilterConfig<D = VxeTableDataRow> {
+    filterMethod?:(params: {
       options: VxeTableDefines.FilterOption[]
       values: any[]
       cellValue: any
-      row: any
-      column: VxeTableDefines.ColumnInfo
+      row: D
+      column: VxeTableDefines.ColumnInfo<D>
     }) => any
     remote?: boolean
     showIcon?: boolean
     iconNone?: string
     iconMatch?: string
   }
-  export interface FilterOpts extends FilterConfig { }
+  export interface FilterOpts<D = VxeTableDataRow> extends FilterConfig<D> { }
 
   /**
    * 单选框配置
    */
-  export interface RadioConfig {
+  export interface RadioConfig<D = VxeTableDataRow> {
     reserve?: boolean
     labelField?: string
     checkRowKey?: string | number
     checkMethod?(params: {
-      row: any
+      row: D
     }): boolean
     visibleMethod?(params: {
-      row: any
+      row: D
     }): boolean
     trigger?: 'default' | 'cell' | 'row' | '' | null
     highlight?: boolean
     strict?: boolean
   }
-  export interface RadioOpts extends RadioConfig { }
+  export interface RadioOpts<D = VxeTableDataRow> extends RadioConfig<D> { }
 
   /**
    * 复选框配置项
    */
-  export interface CheckboxConfig {
+  export interface CheckboxConfig<D = VxeTableDataRow> {
     reserve?: boolean
     labelField?: string
     checkField?: string
@@ -1422,21 +1437,21 @@ export namespace VxeTablePropTypes {
     checkStrictly?: boolean
     strict?: boolean
     checkMethod?(params: {
-      row: any
+      row: D
     }): boolean
     visibleMethod?(params: {
-      row: any
+      row: D
     }): boolean
     trigger?: 'default' | 'cell' | 'row' | '' | null
     highlight?: boolean
     range?: boolean
   }
-  export interface CheckboxOpts extends CheckboxConfig { }
+  export interface CheckboxOpts<D = VxeTableDataRow> extends CheckboxConfig<D> { }
 
   /**
    * 提示信息配置项
    */
-  export interface TooltipConfig {
+  export interface TooltipConfig<D = VxeTableDataRow> {
     showAll?: boolean
     theme?: 'dark' | 'light' | '' | null
     enterable?: boolean
@@ -1444,11 +1459,11 @@ export namespace VxeTablePropTypes {
     leaveDelay?: number
     contentMethod?(params: {
       items: any[]
-      row: any
+      row: D
       rowIndex: number
       $rowIndex: number
       _rowIndex: number
-      column: VxeTableDefines.ColumnInfo
+      column: VxeTableDefines.ColumnInfo<D>
       columnIndex: number
       $columnIndex: number
       _columnIndex: number
@@ -1457,12 +1472,12 @@ export namespace VxeTablePropTypes {
       $event: any
     }): string | null | void
   }
-  export interface TooltipOpts extends TooltipConfig { }
+  export interface TooltipOpts<D = VxeTableDataRow> extends TooltipConfig<D> { }
 
   /**
    * 展开行配置项
    */
-  export interface ExpandConfig {
+  export interface ExpandConfig<D = VxeTableDataRow> {
     labelField?: string
     expandAll?: boolean
     expandRowKeys?: string[] | number[]
@@ -1472,33 +1487,33 @@ export namespace VxeTablePropTypes {
     reserve?: boolean
     height?: number
     loadMethod?(params: {
-      $table: VxeTableConstructor & VxeTablePrivateMethods
-      row: any
+      $table: VxeTableConstructor<D> & VxeTablePrivateMethods<D>
+      row: D
       rowIndex: number
       $rowIndex: number
     }): Promise<void>
     toggleMethod?(params: {
-      $table: VxeTableConstructor & VxeTablePrivateMethods
+      $table: VxeTableConstructor<D> & VxeTablePrivateMethods<D>
       expanded: boolean
-      row: any
+      row: D
       rowIndex: number
       $rowIndex: number
-      column: VxeTableDefines.ColumnInfo
+      column: VxeTableDefines.ColumnInfo<D>
       columnIndex: number
       $columnIndex: number
     }): boolean
-    visibleMethod?(params: VxeTableDefines.CellRenderBodyParams): boolean
+    visibleMethod?(params: VxeTableDefines.CellRenderBodyParams<D>): boolean
     showIcon?: boolean
     iconOpen?: string
     iconClose?: string
     iconLoaded?: string
   }
-  export interface ExpandOpts extends ExpandConfig { }
+  export interface ExpandOpts<D = VxeTableDataRow> extends ExpandConfig<D> { }
 
   /**
    * 树形结构配置项
    */
-  export interface TreeConfig {
+  export interface TreeConfig<D = VxeTableDataRow> {
     transform?: boolean
     rowField?: string
     parentField?: string
@@ -1514,14 +1529,14 @@ export namespace VxeTablePropTypes {
     hasChild?: string
     reserve?: boolean
     loadMethod?(params: {
-      $table: VxeTableConstructor & VxeTablePrivateMethods
-      row: any
+      $table: VxeTableConstructor<D> & VxeTablePrivateMethods<D>
+      row: D
     }): Promise<any[]>
     toggleMethod?(params: {
-      $table: VxeTableConstructor & VxeTablePrivateMethods
+      $table: VxeTableConstructor<D> & VxeTablePrivateMethods<D>
       expanded: boolean
-      row: any
-      column: VxeTableDefines.ColumnInfo
+      row: D
+      column: VxeTableDefines.ColumnInfo<D>
       columnIndex: number
       $columnIndex: number
     }): boolean
@@ -1530,7 +1545,7 @@ export namespace VxeTablePropTypes {
     iconClose?: string
     iconLoaded?: string
   }
-  export interface TreeOpts extends TreeConfig {
+  export interface TreeOpts<D = VxeTableDataRow> extends TreeConfig<D> {
     rowField: string
     parentField: string
     children: string
@@ -1545,7 +1560,7 @@ export namespace VxeTablePropTypes {
   /**
    * 快捷菜单配置项
    */
-  export interface MenuConfig {
+  export interface MenuConfig<D = VxeTableDataRow> {
     header?: VxeTableDefines.MenuOptions
     body?: VxeTableDefines.MenuOptions
     footer?: VxeTableDefines.MenuOptions
@@ -1554,10 +1569,10 @@ export namespace VxeTablePropTypes {
     visibleMethod?(params: {
       type: string
       options: VxeTableDefines.MenuFirstOption[][]
-      columns: VxeTableDefines.ColumnInfo[]
-      row?: any
+      columns: VxeTableDefines.ColumnInfo<D>[]
+      row?: D
       rowIndex?: number
-      column?: VxeTableDefines.ColumnInfo
+      column?: VxeTableDefines.ColumnInfo<D>
       columnIndex?: number
     }): boolean
   }
@@ -1581,7 +1596,7 @@ export namespace VxeTablePropTypes {
   /**
    * 区域配置项
    */
-  export interface AreaConfig {
+  export interface AreaConfig<D = VxeTableDataRow> {
     /**
      * 只对 mouse-config.area 启用后有效，点击列头是否选取当前列的所有单元格
      */
@@ -1598,35 +1613,35 @@ export namespace VxeTablePropTypes {
      * 只对 extendByCalc 启用后有效，重写单元格扩展区域计算值的方法
      * @param params
      */
-    extendCalcMethod?(params: VxeTableProDefines.ExtendCellAreaCalcBaseParams): any[][]
+    extendCalcMethod?(params: VxeTableProDefines.ExtendCellAreaCalcBaseParams<D>): any[][]
     /**
      * 只对 extendByCopy | extendByCalc 启用后有效，重写单元格扩展区域赋值的方法
      * @param params
      */
     extendSetMethod?(params: {
       cellValue: any
-      row: any
-      column: VxeTableDefines.ColumnInfo
-    } & VxeTableProDefines.ExtendCellAreaCalcBaseParams): void
+      row: D
+      column: VxeTableDefines.ColumnInfo<D>
+    } & VxeTableProDefines.ExtendCellAreaCalcBaseParams<D>): void
     /**
      * 只对 extendByCopy | extendByCalc 启用后有效，自定义单元格扩展区域赋值之前的方法，可以通过返回 false 阻止扩展行为
      * @param params
      */
-    beforeExtendSetMethod?(params: VxeTableProDefines.ExtendCellAreaCalcBaseParams): boolean
+    beforeExtendSetMethod?(params: VxeTableProDefines.ExtendCellAreaCalcBaseParams<D>): boolean
     /**
      * 只对 extendByCopy | extendByCalc 启用后有效，自定义单元格扩展区域赋值之后的方法
      * @param params
      */
     afterExtendSetMethod?(params: {
       extendValues: any[][]
-    } & VxeTableProDefines.ExtendCellAreaCalcBaseParams): boolean
+    } & VxeTableProDefines.ExtendCellAreaCalcBaseParams<D>): boolean
   }
-  export interface AreaOpts extends AreaConfig { }
+  export interface AreaOpts<D = VxeTableDataRow> extends AreaConfig<D> { }
 
   /**
    * 按键配置项
    */
-  export interface KeyboardConfig {
+  export interface KeyboardConfig<D = VxeTableDataRow> {
     /**
      * 是否开启非编辑状态下，上下左右移动功能
      */
@@ -1679,40 +1694,40 @@ export namespace VxeTablePropTypes {
      * 只对 isDel=true 有效，用于删除键清空单元格内容方法
      */
     delMethod?(params: {
-      row: any
+      row: D
       rowIndex: number
-      column: VxeTableDefines.ColumnInfo
+      column: VxeTableDefines.ColumnInfo<D>
       columnIndex: number
-      $table: VxeTableConstructor & VxeTablePrivateMethods
+      $table: VxeTableConstructor<D> & VxeTablePrivateMethods<D>
     }): void
     /**
      * 只对 isDel=true 有效，用于重写回退键清空单元格内容并激活为编辑状态方法
      */
     backMethod?(params: {
-      row: any
+      row: D
       rowIndex: number
-      column: VxeTableDefines.ColumnInfo
+      column: VxeTableDefines.ColumnInfo<D>
       columnIndex: number
-      $table: VxeTableConstructor & VxeTablePrivateMethods
+      $table: VxeTableConstructor<D> & VxeTablePrivateMethods<D>
     }): void
     /**
      * 只对 isEdit=true 有效，用于重写编辑单元格方法
      */
     editMethod?(params: {
-      row: any
+      row: D
       rowIndex: number
-      column: VxeTableDefines.ColumnInfo
+      column: VxeTableDefines.ColumnInfo<D>
       columnIndex: number
-      $table: VxeTableConstructor & VxeTablePrivateMethods
-      $grid: VxeGridConstructor | null | undefined
+      $table: VxeTableConstructor<D> & VxeTablePrivateMethods<D>
+      $grid: VxeGridConstructor<D> | null | undefined
     }): boolean
   }
-  export interface KeyboardOpts extends KeyboardConfig { }
+  export interface KeyboardOpts<D = VxeTableDataRow> extends KeyboardConfig<D> { }
 
   /**
    * 复制/粘贴配置项
    */
-  export interface ClipConfig {
+  export interface ClipConfig<DT = VxeTableDataRow> {
     /**
      * 是否启用复制功能
      */
@@ -1742,11 +1757,11 @@ export namespace VxeTablePropTypes {
      */
     copyMethod?(params: {
       isCut: boolean
-      row: any
-      column: VxeTableDefines.ColumnInfo
+      row: DT
+      column: VxeTableDefines.ColumnInfo<DT>
       cellValue: any
-      $table: VxeTableConstructor & VxeTablePrivateMethods
-      $grid: VxeGridConstructor | null | undefined
+      $table: VxeTableConstructor<DT> & VxeTablePrivateMethods<DT>
+      $grid: VxeGridConstructor<DT> | null | undefined
     }): string
     /**
      * 自定义单元格复制取值之前的方法，可以通过返回 false 阻止复制行为
@@ -1754,58 +1769,58 @@ export namespace VxeTablePropTypes {
     beforeCopyMethod?(params: {
       isCut: boolean
       activeArea: VxeTableProDefines.MouseActiveCellArea
-      targetAreas: VxeTableProDefines.CellAreaParams[]
-      $table: VxeTableConstructor & VxeTablePrivateMethods
-      $grid: VxeGridConstructor | null | undefined
+      targetAreas: VxeTableProDefines.CellAreaParams<DT>[]
+      $table: VxeTableConstructor<DT> & VxeTablePrivateMethods<DT>
+      $grid: VxeGridConstructor<DT> | null | undefined
     }): boolean
     /**
      * 自定义单元格复制到剪贴板之后的方法
      */
     afterCopyMethod?(params: {
       isCut: boolean
-      targetAreas: VxeTableProDefines.CellAreaParams[]
-      $table: VxeTableConstructor & VxeTablePrivateMethods
-      $grid: VxeGridConstructor | null | undefined
+      targetAreas: VxeTableProDefines.CellAreaParams<DT>[]
+      $table: VxeTableConstructor<DT> & VxeTablePrivateMethods<DT>
+      $grid: VxeGridConstructor<DT> | null | undefined
     }): boolean
     /**
      * 重写单元格剪贴值清除的方法，将剪贴单元格的值清除
      */
-    cutMethod?: (params: {
-      row: any,
-      column: VxeTableDefines.ColumnInfo
+    cutMethod?:(params: {
+      row: DT,
+      column: VxeTableDefines.ColumnInfo<DT>
       cellValue: any
-      $table: VxeTableConstructor & VxeTablePrivateMethods
-      $grid: VxeGridConstructor | null | undefined
+      $table: VxeTableConstructor<DT> & VxeTablePrivateMethods<DT>
+      $grid: VxeGridConstructor<DT> | null | undefined
     }) => void
     /**
      * 自定义单元格剪贴值清除之前的方法，可以通过返回 false 阻止清除行为
      */
-    beforeCutMethod?: (params: {
+    beforeCutMethod?:(params: {
       activeArea: VxeTableProDefines.MouseActiveCellArea
-      cutAreas: VxeTableProDefines.CellAreaParams[]
-      currentAreas: VxeTableProDefines.CellAreaParams[]
-      $table: VxeTableConstructor & VxeTablePrivateMethods
-      $grid: VxeGridConstructor | null | undefined
+      cutAreas: VxeTableProDefines.CellAreaParams<DT>[]
+      currentAreas: VxeTableProDefines.CellAreaParams<DT>[]
+      $table: VxeTableConstructor<DT> & VxeTablePrivateMethods<DT>
+      $grid: VxeGridConstructor<DT> | null | undefined
     }) => boolean
     /**
      * 自定义单元格剪贴值清除之后的方法
      */
-    afterCutMethod?: (params: {
-      cutAreas: VxeTableProDefines.CellAreaParams[]
-      currentAreas: VxeTableProDefines.CellAreaParams[]
-      $table: VxeTableConstructor & VxeTablePrivateMethods
-      $grid: VxeGridConstructor | null | undefined
+    afterCutMethod?:(params: {
+      cutAreas: VxeTableProDefines.CellAreaParams<DT>[]
+      currentAreas: VxeTableProDefines.CellAreaParams<DT>[]
+      $table: VxeTableConstructor<DT> & VxeTablePrivateMethods<DT>
+      $grid: VxeGridConstructor<DT> | null | undefined
     }) => void
     /**
      * 重写单元格粘贴赋值的方法，从剪贴板赋值到单元格
      */
     pasteMethod?(params: {
       isCut: boolean
-      row: any,
-      column: VxeTableDefines.ColumnInfo
+      row: DT,
+      column: VxeTableDefines.ColumnInfo<DT>
       cellValue: any
-      $table: VxeTableConstructor & VxeTablePrivateMethods
-      $grid: VxeGridConstructor | null | undefined
+      $table: VxeTableConstructor<DT> & VxeTablePrivateMethods<DT>
+      $grid: VxeGridConstructor<DT> | null | undefined
     }): void
     /**
      * 自定义单元格粘贴赋值之前的方法，可以通过返回 false 阻止复制行为
@@ -1813,60 +1828,60 @@ export namespace VxeTablePropTypes {
     beforePasteMethod?(params: {
       isCut: boolean
       activeArea: VxeTableProDefines.MouseActiveCellArea
-      cutAreas: VxeTableProDefines.CellAreaParams[]
-      currentAreas: VxeTableProDefines.CellAreaParams[]
-      targetAreas: VxeTableProDefines.CellAreaParams[]
+      cutAreas: VxeTableProDefines.CellAreaParams<DT>[]
+      currentAreas: VxeTableProDefines.CellAreaParams<DT>[]
+      targetAreas: VxeTableProDefines.CellAreaParams<DT>[]
       cellValues: string[][]
       pasteCells: string[][]
-      $table: VxeTableConstructor & VxeTablePrivateMethods
-      $grid: VxeGridConstructor | null | undefined
+      $table: VxeTableConstructor<DT> & VxeTablePrivateMethods<DT>
+      $grid: VxeGridConstructor<DT> | null | undefined
     }): boolean
     /**
      * 自定义单元格粘贴赋值之后的方法
      */
     afterPasteMethod?(params: {
       isCut: boolean
-      currentAreas: VxeTableProDefines.CellAreaParams[]
-      cutAreas: VxeTableProDefines.CellAreaParams[]
-      targetAreas: VxeTableProDefines.CellAreaParams[]
+      currentAreas: VxeTableProDefines.CellAreaParams<DT>[]
+      cutAreas: VxeTableProDefines.CellAreaParams<DT>[]
+      targetAreas: VxeTableProDefines.CellAreaParams<DT>[]
       cellValues: any[][]
       pasteCells: string[][]
-      insertRows: any[]
-      insertColumns: VxeTableDefines.ColumnInfo[]
-      $table: VxeTableConstructor & VxeTablePrivateMethods
-      $grid: VxeGridConstructor | null | undefined
+      insertRows: DT[]
+      insertColumns: VxeTableDefines.ColumnInfo<DT>[]
+      $table: VxeTableConstructor<DT> & VxeTablePrivateMethods<DT>
+      $grid: VxeGridConstructor<DT> | null | undefined
     }): boolean
     /**
      * 只对 isRowIncrement 有效，自定义创建自增行数据的方法
      */
     createRowsMethod?(params: {
-      currentAreas: VxeTableProDefines.CellAreaParams[]
-      targetAreas: VxeTableProDefines.CellAreaParams[]
+      currentAreas: VxeTableProDefines.CellAreaParams<DT>[]
+      targetAreas: VxeTableProDefines.CellAreaParams<DT>[]
       cellValues: any[][]
       pasteCells: string[][]
-      insertRows: any[]
-      $table: VxeTableConstructor & VxeTablePrivateMethods
-      $grid: VxeGridConstructor | null | undefined
-    }): any[]
+      insertRows: DT[]
+      $table: VxeTableConstructor<DT> & VxeTablePrivateMethods<DT>
+      $grid: VxeGridConstructor<DT> | null | undefined
+    }): DT[]
     /**
      * 只对 isColumnIncrement 有效，自定义创建自增列配置的方法
      */
     createColumnsMethod?(params: {
-      currentAreas: VxeTableProDefines.CellAreaParams[]
-      targetAreas: VxeTableProDefines.CellAreaParams[]
+      currentAreas: VxeTableProDefines.CellAreaParams<DT>[]
+      targetAreas: VxeTableProDefines.CellAreaParams<DT>[]
       cellValues: any[][]
       pasteCells: string[][]
       insertColumns: VxeTableDefines.ColumnOptions[]
-      $table: VxeTableConstructor & VxeTablePrivateMethods
-      $grid: VxeGridConstructor | null | undefined
-    }): VxeTableDefines.ColumnOptions[]
+      $table: VxeTableConstructor<DT> & VxeTablePrivateMethods<DT>
+      $grid: VxeGridConstructor<DT> | null | undefined
+    }): VxeTableDefines.ColumnOptions<DT>[]
   }
-  export interface ClipOpts extends ClipConfig { }
+  export interface ClipOpts<D = VxeTableDataRow> extends ClipConfig<D> { }
 
   /**
    * 查找/替换配置项
    */
-  export interface FNRConfig {
+  export interface FNRConfig<DT = VxeTableDataRow> {
     isFind?: boolean
     findMethod?(params: {
       cellValue: any
@@ -1879,44 +1894,44 @@ export namespace VxeTablePropTypes {
     beforeFindMethod?(params: {
       isAll: boolean
       findValue: string | null
-      $table: VxeTableConstructor & VxeTablePrivateMethods
-      $grid: VxeGridConstructor | null | undefined
+      $table: VxeTableConstructor<DT> & VxeTablePrivateMethods<DT>
+      $grid: VxeGridConstructor<DT> | null | undefined
     }): boolean
     afterFindMethod?(params: {
       isAll: boolean
       findValue: string | null
       result: VxeTableProDefines.FindAndReplaceResult[]
-      $table: VxeTableConstructor & VxeTablePrivateMethods
-      $grid: VxeGridConstructor | null | undefined
+      $table: VxeTableConstructor<DT> & VxeTablePrivateMethods<DT>
+      $grid: VxeGridConstructor<DT> | null | undefined
     }): void
     isReplace?: boolean
-    replaceMethod?: (params: {
-      row: any
-      column: VxeTableDefines.ColumnInfo
+    replaceMethod?:(params: {
+      row: DT
+      column: VxeTableDefines.ColumnInfo<DT>
       cellValue: any
     }) => void
-    beforeReplaceMethod?: (params: {
+    beforeReplaceMethod?:(params: {
       isAll: boolean
       findValue: string | null
       replaceValue: string
-      $table: VxeTableConstructor & VxeTablePrivateMethods
-      $grid: VxeGridConstructor | null | undefined
+      $table: VxeTableConstructor<DT> & VxeTablePrivateMethods<DT>
+      $grid: VxeGridConstructor<DT> | null | undefined
     }) => boolean
-    afterReplaceMethod?: (params: {
+    afterReplaceMethod?:(params: {
       isAll: boolean
       findValue: string | null
       replaceValue: string
       result: VxeTableProDefines.FindAndReplaceResult[]
-      $table: VxeTableConstructor & VxeTablePrivateMethods
-      $grid: VxeGridConstructor | null | undefined
+      $table: VxeTableConstructor<DT> & VxeTablePrivateMethods<DT>
+      $grid: VxeGridConstructor<DT> | null | undefined
     }) => void
   }
-  export interface FNROpts extends FNRConfig { }
+  export interface FNROpts<D = VxeTableDataRow> extends FNRConfig<D> { }
 
   /**
    * 编辑配置项
    */
-  export interface EditConfig {
+  export interface EditConfig<DT = VxeTableDataRow> {
     trigger?: 'manual' | 'click' | 'dblclick' | '' | null
     enabled?: boolean
     mode?: string
@@ -1931,27 +1946,27 @@ export namespace VxeTablePropTypes {
      * 该方法的返回值用来决定该单元格是否允许编辑
      */
     beforeEditMethod?(params: {
-      row: any
+      row: DT
       rowIndex: number
-      column: VxeTableDefines.ColumnInfo
+      column: VxeTableDefines.ColumnInfo<DT>
       columnIndex: number
-      $table: VxeTableConstructor & VxeTablePrivateMethods
-      $grid: VxeGridConstructor | null | undefined
+      $table: VxeTableConstructor<DT> & VxeTablePrivateMethods<DT>
+      $grid: VxeGridConstructor<DT> | null | undefined
     }): boolean
     /**
      * 请使用 beforeEditMethod
      * @deprecated
      */
     activeMethod?(params: {
-      row: any
+      row: DT
       rowIndex: number
-      column: VxeTableDefines.ColumnInfo
+      column: VxeTableDefines.ColumnInfo<DT>
       columnIndex: number
-      $table: VxeTableConstructor & VxeTablePrivateMethods
-      $grid: VxeGridConstructor | null | undefined
+      $table: VxeTableConstructor<DT> & VxeTablePrivateMethods<DT>
+      $grid: VxeGridConstructor<DT> | null | undefined
     }): boolean
   }
-  export interface EditOpts extends EditConfig { }
+  export interface EditOpts<D = VxeTableDataRow> extends EditConfig<D> { }
 
   /**
    * 校验配置项
@@ -1959,6 +1974,10 @@ export namespace VxeTablePropTypes {
   export interface ValidConfig {
     autoPos?: boolean
     showMessage?: boolean
+    /**
+     * 不建议使用，后续废弃
+     * @deprecated
+     */
     message?: string
     maxWidth?: number
   }
@@ -1967,8 +1986,8 @@ export namespace VxeTablePropTypes {
   /**
    * 校验规则配置项
    */
-  export interface EditRules {
-    [field: string]: VxeTableDefines.ValidatorRule[]
+  export interface EditRules<D = VxeTableDataRow> {
+    [field: string]: VxeTableDefines.ValidatorRule<D>[]
   }
 
   export type ZIndex = number
@@ -2018,14 +2037,14 @@ export namespace VxeTablePropTypes {
   export type Params = any
 }
 
-export type VxeTableProps<D = any> = {
+export type VxeTableProps<D = VxeTableDataRow> = {
   size?: VxeTablePropTypes.Size
   id?: VxeTablePropTypes.ID
   data?: VxeTablePropTypes.Data<D>
   height?: VxeTablePropTypes.Height
   maxHeight?: VxeTablePropTypes.MaxHeight
   /**
-   * 不建议使用，后续废弃
+   * 不建议使用，被 column-config.resizable 替换
    * @deprecated
    */
   resizable?: VxeTablePropTypes.Resizable
@@ -2037,9 +2056,25 @@ export type VxeTableProps<D = any> = {
   headerAlign?: VxeTablePropTypes.HeaderAlign
   footerAlign?: VxeTablePropTypes.FooterAlign
   showHeader?: VxeTablePropTypes.ShowHeader
+  /**
+   * 不建议使用，被 row-config.isCurrent 替换
+   * @deprecated
+   */
   highlightCurrentRow?: VxeTablePropTypes.HighlightCurrentRow
+  /**
+   * 不建议使用，被 row-config.isHover 替换
+   * @deprecated
+   */
   highlightHoverRow?: VxeTablePropTypes.HighlightHoverRow
+  /**
+   * 不建议使用，被 column-config.isCurrent 替换
+   * @deprecated
+   */
   highlightCurrentColumn?: VxeTablePropTypes.HighlightCurrentColumn
+  /**
+   * 不建议使用，被 column-config.isHover 替换
+   * @deprecated
+   */
   highlightHoverColumn?: VxeTablePropTypes.HighlightHoverColumn
   /**
    * 已废弃
@@ -2047,23 +2082,23 @@ export type VxeTableProps<D = any> = {
    */
   highlightCell?: VxeTablePropTypes.HighlightCell
   showFooter?: VxeTablePropTypes.ShowFooter
-  footerMethod?: VxeTablePropTypes.FooterMethod
-  rowClassName?: VxeTablePropTypes.RowClassName
-  cellClassName?: VxeTablePropTypes.CellClassName
-  headerRowClassName?: VxeTablePropTypes.HeaderRowClassName
-  headerCellClassName?: VxeTablePropTypes.HeaderCellClassName
-  footerRowClassName?: VxeTablePropTypes.FooterRowClassName
-  footerCellClassName?: VxeTablePropTypes.FooterCellClassName
-  cellStyle?: VxeTablePropTypes.CellStyle
-  headerCellStyle?: VxeTablePropTypes.HeaderCellStyle
-  footerCellStyle?: VxeTablePropTypes.FooterCellStyle
-  rowStyle?: VxeTablePropTypes.RowStyle
-  headerRowStyle?: VxeTablePropTypes.HeaderRowStyle
-  footerRowStyle?: VxeTablePropTypes.FooterRowStyle
-  mergeCells?: VxeTablePropTypes.MergeCells
-  mergeFooterItems?: VxeTablePropTypes.MergeFooterItems
-  spanMethod?: VxeTablePropTypes.SpanMethod
-  footerSpanMethod?: VxeTablePropTypes.FooterSpanMethod
+  footerMethod?: VxeTablePropTypes.FooterMethod<D>
+  rowClassName?: VxeTablePropTypes.RowClassName<D>
+  cellClassName?: VxeTablePropTypes.CellClassName<D>
+  headerRowClassName?: VxeTablePropTypes.HeaderRowClassName<D>
+  headerCellClassName?: VxeTablePropTypes.HeaderCellClassName<D>
+  footerRowClassName?: VxeTablePropTypes.FooterRowClassName<D>
+  footerCellClassName?: VxeTablePropTypes.FooterCellClassName<D>
+  cellStyle?: VxeTablePropTypes.CellStyle<D>
+  rowStyle?: VxeTablePropTypes.RowStyle<D>
+  headerCellStyle?: VxeTablePropTypes.HeaderCellStyle<D>
+  headerRowStyle?: VxeTablePropTypes.HeaderRowStyle<D>
+  footerRowStyle?: VxeTablePropTypes.FooterRowStyle<D>
+  footerCellStyle?: VxeTablePropTypes.FooterCellStyle<D>
+  mergeCells?: VxeTablePropTypes.MergeCells<D>
+  mergeFooterItems?: VxeTablePropTypes.MergeFooterItems<D>
+  spanMethod?: VxeTablePropTypes.SpanMethod<D>
+  footerSpanMethod?: VxeTablePropTypes.FooterSpanMethod<D>
   showOverflow?: VxeTablePropTypes.ShowOverflow
   showHeaderOverflow?: VxeTablePropTypes.ShowHeaderOverflow
   showFooterOverflow?: VxeTablePropTypes.ShowFooterOverflow
@@ -2087,44 +2122,44 @@ export type VxeTableProps<D = any> = {
   syncResize?: VxeTablePropTypes.SyncResize
   columnConfig?: VxeTablePropTypes.ColumnConfig
   rowConfig?: VxeTablePropTypes.RowConfig
-  customConfig?: VxeTablePropTypes.CustomConfig
+  customConfig?: VxeTablePropTypes.CustomConfig<D>
   resizeConfig?: VxeTablePropTypes.ResizeConfig
-  resizableConfig?: VxeTablePropTypes.ResizableConfig
-  seqConfig?: VxeTablePropTypes.SeqConfig
-  sortConfig?: VxeTablePropTypes.SortConfig
-  filterConfig?: VxeTablePropTypes.FilterConfig
-  radioConfig?: VxeTablePropTypes.RadioConfig
-  checkboxConfig?: VxeTablePropTypes.CheckboxConfig
-  tooltipConfig?: VxeTablePropTypes.TooltipConfig
+  resizableConfig?: VxeTablePropTypes.ResizableConfig<D>
+  seqConfig?: VxeTablePropTypes.SeqConfig<D>
+  sortConfig?: VxeTablePropTypes.SortConfig<D>
+  filterConfig?: VxeTablePropTypes.FilterConfig<D>
+  radioConfig?: VxeTablePropTypes.RadioConfig<D>
+  checkboxConfig?: VxeTablePropTypes.CheckboxConfig<D>
+  tooltipConfig?: VxeTablePropTypes.TooltipConfig<D>
   exportConfig?: VxeTablePropTypes.ExportConfig
   importConfig?: VxeTablePropTypes.ImportConfig
   printConfig?: VxeTablePropTypes.PrintConfig
-  expandConfig?: VxeTablePropTypes.ExpandConfig
-  treeConfig?: VxeTablePropTypes.TreeConfig
-  menuConfig?: VxeTablePropTypes.MenuConfig
+  expandConfig?: VxeTablePropTypes.ExpandConfig<D>
+  treeConfig?: VxeTablePropTypes.TreeConfig<D>
+  menuConfig?: VxeTablePropTypes.MenuConfig<D>
   mouseConfig?: VxeTablePropTypes.MouseConfig
-  areaConfig?: VxeTablePropTypes.AreaConfig
-  fnrConfig?: VxeTablePropTypes.FNRConfig
-  keyboardConfig?: VxeTablePropTypes.KeyboardConfig
-  clipConfig?: VxeTablePropTypes.ClipConfig
-  editConfig?: VxeTablePropTypes.EditConfig
+  areaConfig?: VxeTablePropTypes.AreaConfig<D>
+  fnrConfig?: VxeTablePropTypes.FNRConfig<D>
+  keyboardConfig?: VxeTablePropTypes.KeyboardConfig<D>
+  clipConfig?: VxeTablePropTypes.ClipConfig<D>
+  editConfig?: VxeTablePropTypes.EditConfig<D>
   validConfig?: VxeTablePropTypes.ValidConfig
-  editRules?: VxeTablePropTypes.EditRules
+  editRules?: VxeTablePropTypes.EditRules<D>
   emptyText?: VxeTablePropTypes.EmptyText
   emptyRender?: VxeTablePropTypes.EmptyRender
   loadingConfig?: VxeTablePropTypes.LoadingConfig
   /**
-   * 不建议使用，后续废弃
+   * 不建议使用，已废弃
    * @deprecated
    */
   fit?: VxeTablePropTypes.Fit
   /**
-   * 不建议使用，后续废弃
+   * 不建议使用，已废弃
    * @deprecated
    */
   animat?: VxeTablePropTypes.Animat
   /**
-   * 不建议使用，后续废弃
+   * 不建议使用，已废弃
    * @deprecated
    */
   delayHover?: VxeTablePropTypes.DelayHover
@@ -2186,9 +2221,9 @@ export namespace VxeTableDefines {
     order?: VxeTablePropTypes.SortOrder
   }
 
-  export interface MergeOptions {
+  export interface MergeOptions<D = VxeTableDataRow> {
     row: any | number
-    col: VxeTableDefines.ColumnInfo | number
+    col: VxeTableDefines.ColumnInfo<D> | number
     rowspan: number
     colspan: number
   }
@@ -2200,22 +2235,22 @@ export namespace VxeTableDefines {
     colspan: number
   }
 
-  export interface MergeItem extends MergeInfo {
+  export interface MergeItem<D = VxeTableDataRow> extends MergeInfo {
     _row: any
-    _col: VxeTableDefines.ColumnInfo
+    _col: VxeTableDefines.ColumnInfo<D>
     _rowspan: number
     _colspan: number
   }
 
-  export interface ColumnOptions extends VxeColumnProps {
-    children?: ColumnOptions[]
-    slots?: VxeColumnPropTypes.Slots
+  export interface ColumnOptions<D = VxeTableDataRow> extends VxeColumnProps<D> {
+    children?: ColumnOptions<D>[]
+    slots?: VxeColumnPropTypes.Slots<any>
   }
 
   /**
    * 列对象
    */
-  export class ColumnInfo {
+  export class ColumnInfo<D = VxeTableDataRow> {
     /**
      * 该属性已废弃，该属性被 field 替换
      * @deprecated
@@ -2242,17 +2277,17 @@ export namespace VxeTableDefines {
     className: VxeColumnPropTypes.ClassName
     headerClassName: VxeColumnPropTypes.HeaderClassName
     footerClassName: VxeColumnPropTypes.FooterClassName
-    formatter: VxeColumnPropTypes.Formatter
+    formatter: VxeColumnPropTypes.Formatter<D>
     sortable: VxeColumnPropTypes.Sortable
     sortBy: VxeColumnPropTypes.SortBy
     sortType: VxeColumnPropTypes.SortType
     filters: VxeColumnPropTypes.Filter[]
     filterMultiple: VxeColumnPropTypes.FilterMultiple
-    filterMethod: VxeColumnPropTypes.FilterMethod
+    filterMethod: VxeColumnPropTypes.FilterMethod<D>
     filterRender: VxeColumnPropTypes.FilterRender
     treeNode: VxeColumnPropTypes.TreeNode
     visible: VxeColumnPropTypes.Visible
-    exportMethod: VxeColumnPropTypes.ExportMethod
+    exportMethod: VxeColumnPropTypes.ExportMethod<D>
     footerExportMethod: VxeColumnPropTypes.FooterExportMethod
     /**
      * 已废弃，请使用 titlePrefix
@@ -2261,11 +2296,11 @@ export namespace VxeTableDefines {
     titleHelp: VxeColumnPropTypes.TitleHelp
     titlePrefix: VxeColumnPropTypes.TitlePrefix
     cellType: VxeColumnPropTypes.CellType
-    cellRender: VxeColumnPropTypes.CellRender
+    cellRender: VxeColumnPropTypes.CellRender<D>
     editRender: VxeColumnPropTypes.EditRender
     contentRender: VxeColumnPropTypes.ContentRender
     params: VxeColumnPropTypes.Params
-    slots: VxeColumnPropTypes.Slots
+    slots: VxeColumnPropTypes.Slots<D>
 
     /**
      * 以下内部属性
@@ -2291,21 +2326,22 @@ export namespace VxeTableDefines {
       value: any
     }
 
-    children: ColumnInfo[]
+    children: ColumnInfo<D>[]
 
-    renderHeader(params: CellRenderHeaderParams): VNode[]
-    renderCell(params: CellRenderCellParams): VNode[]
-    renderData(params: CellRenderDataParams): VNode[]
-    renderFooter(params: CellRenderFooterParams): VNode[]
+    renderHeader(params: CellRenderHeaderParams<D>): VNode[]
+    renderCell(params: CellRenderCellParams<D>): VNode[]
+    renderData(params: CellRenderDataParams<D>): VNode[]
+    renderFooter(params: CellRenderFooterParams<D>): VNode[]
 
     getTitle(): string
     getKey(): string
   }
-  export interface CellRenderHeaderParams {
-    $table: VxeTableConstructor & VxeTablePrivateMethods
-    $grid: VxeGridConstructor | null
+
+  export interface CellRenderHeaderParams<D = VxeTableDataRow> {
+    $table: VxeTableConstructor<D> & VxeTablePrivateMethods<D>
+    $grid: VxeGridConstructor<D> | null
     $rowIndex: number
-    column: ColumnInfo
+    column: ColumnInfo<D>
     columnIndex: number
     $columnIndex: number
     _columnIndex: number
@@ -2314,16 +2350,17 @@ export namespace VxeTableDefines {
     isHidden: boolean
     hasFilter: boolean
   }
-  export interface CellRenderBodyParams {
-    $table: VxeTableConstructor & VxeTablePrivateMethods
-    $grid: VxeGridConstructor | null
+
+  export interface CellRenderBodyParams<D = VxeTableDataRow> {
+    $table: VxeTableConstructor<D> & VxeTablePrivateMethods<D>
+    $grid: VxeGridConstructor<D> | null
     seq: string | number
     rowid: string
-    row: any
+    row: D
     rowIndex: number
     $rowIndex: number
     _rowIndex: number
-    column: ColumnInfo
+    column: ColumnInfo<D>
     columnIndex: number
     $columnIndex: number
     _columnIndex: number
@@ -2331,20 +2368,20 @@ export namespace VxeTableDefines {
     type: string
     isHidden: boolean
     level: number
-    visibleData: any[]
-    data: any[]
+    visibleData: D[]
+    data: D[]
     items: any[]
   }
 
-  export interface CellRenderDataParams extends CellRenderBodyParams { }
-  export interface CellRenderCellParams extends CellRenderBodyParams { }
+  export interface CellRenderDataParams<D = VxeTableDataRow> extends CellRenderBodyParams<D> { }
+  export interface CellRenderCellParams<D = VxeTableDataRow> extends CellRenderBodyParams<D> { }
 
-  export interface CellRenderFooterParams {
-    $table: VxeTableConstructor & VxeTablePrivateMethods
-    $grid: VxeGridConstructor | null
+  export interface CellRenderFooterParams<D = VxeTableDataRow> {
+    $table: VxeTableConstructor<D> & VxeTablePrivateMethods<D>
+    $grid: VxeGridConstructor<D> | null
     _rowIndex: number
     $rowIndex: number
-    column: ColumnInfo
+    column: ColumnInfo<D>
     columnIndex: number
     $columnIndex: number
     _columnIndex: number
@@ -2355,212 +2392,212 @@ export namespace VxeTableDefines {
     data: any[][]
   }
 
-  interface TableEventParams extends VxeEvent {
-    $table: VxeTableConstructor & VxeTablePrivateMethods
+  interface TableEventParams<D = VxeTableDataRow> extends VxeEvent {
+    $table: VxeTableConstructor<D> & VxeTablePrivateMethods<D>
   }
 
-  interface TableBaseHeaderCellParams {
+  interface TableBaseHeaderCellParams<D = VxeTableDataRow> {
     $rowIndex: number
-    column: ColumnInfo
+    column: ColumnInfo<D>
     columnIndex: number
     $columnIndex: number
   }
 
-  interface TableBaseCellParams {
-    row: any
+  interface TableBaseCellParams<D = VxeTableDataRow> {
+    row: D
     rowIndex: number
     $rowIndex: number
-    column: ColumnInfo
+    column: ColumnInfo<D>
     columnIndex: number
     $columnIndex: number
   }
 
-  interface TableBaseFooterCellParams {
+  interface TableBaseFooterCellParams<D = VxeTableDataRow> {
     $rowIndex: number
-    column: ColumnInfo
+    column: ColumnInfo<D>
     columnIndex: number
     $columnIndex: number
   }
 
   export interface KeydownStartParams { }
-  export interface KeydownStartEventParams extends TableEventParams, KeydownStartParams { }
+  export interface KeydownStartEventParams<D = VxeTableDataRow> extends TableEventParams<D>, KeydownStartParams { }
 
   export interface KeydownParams { }
-  export interface KeydownEventParams extends TableEventParams, KeydownParams { }
+  export interface KeydownEventParams<D = VxeTableDataRow> extends TableEventParams<D>, KeydownParams { }
 
   export interface KeydownEndParams { }
-  export interface KeydownEndEventParams extends TableEventParams, KeydownEndParams { }
+  export interface KeydownEndEventParams<D = VxeTableDataRow> extends TableEventParams<D>, KeydownEndParams { }
 
   export interface PasteParams { }
-  export interface PasteEventParams extends TableEventParams, PasteParams { }
+  export interface PasteEventParams<D = VxeTableDataRow> extends TableEventParams<D>, PasteParams { }
 
   export interface CopyParams { }
-  export interface CopyEventParams extends TableEventParams, CopyParams { }
+  export interface CopyEventParams<D = VxeTableDataRow> extends TableEventParams<D>, CopyParams { }
 
   export interface CutParams { }
-  export interface CutEventParams extends TableEventParams, CutParams { }
+  export interface CutEventParams<D = VxeTableDataRow> extends TableEventParams<D>, CutParams { }
 
-  export interface CurrentChangeParams extends TableBaseCellParams {
+  export interface CurrentChangeParams<D = VxeTableDataRow> extends TableBaseCellParams<D> {
     newValue: any
     oldValue: any
   }
-  export interface CurrentChangeEventParams extends TableEventParams, CurrentChangeParams { }
+  export interface CurrentChangeEventParams<D = VxeTableDataRow> extends TableEventParams<D>, CurrentChangeParams { }
 
-  export interface RadioChangeParams extends TableBaseCellParams {
+  export interface RadioChangeParams<D = VxeTableDataRow> extends TableBaseCellParams<D> {
     newValue: any
     oldValue: any
   }
-  export interface RadioChangeEventParams extends TableEventParams, RadioChangeParams { }
+  export interface RadioChangeEventParams<D = VxeTableDataRow> extends TableEventParams<D>, RadioChangeParams { }
 
-  export interface CheckboxChangeParams extends TableBaseCellParams {
+  export interface CheckboxChangeParams<D = VxeTableDataRow> extends TableBaseCellParams<D> {
     checked: boolean
     /**
      * 请调用方法 getCheckboxRecords() 获取
      * @deprecated
      */
-    records: any[]
+    records: D[]
     /**
      * 请调用方法 getCheckboxReserveRecords() 获取
      * @deprecated
      */
-    reserves: any[]
+    reserves: D[]
     /**
      * 请调用方法 getCheckboxIndeterminateRecords() 获取
      * @deprecated
      */
-    indeterminates: any[]
+    indeterminates: D[]
   }
-  export interface CheckboxChangeEventParams extends TableEventParams, CheckboxChangeParams { }
+  export interface CheckboxChangeEventParams<D = VxeTableDataRow> extends TableEventParams<D>, CheckboxChangeParams<D> { }
 
-  export interface CheckboxAllParams extends CheckboxChangeParams { }
-  export interface CheckboxAllEventParams extends TableEventParams, CheckboxAllParams { }
+  export interface CheckboxAllParams<D = VxeTableDataRow> extends CheckboxChangeParams<D> { }
+  export interface CheckboxAllEventParams<D = VxeTableDataRow> extends TableEventParams<D>, CheckboxAllParams<D> { }
 
-  export interface CheckboxRangeStartParams {
+  export interface CheckboxRangeStartParams<D = VxeTableDataRow> {
     /**
      * 请调用方法 getCheckboxRecords() 获取
      * @deprecated
      */
-    records: any[]
+    records: D[]
     /**
      * 请调用方法 getCheckboxReserveRecords() 获取
      * @deprecated
      */
-    reserves: any[]
+    reserves: D[]
   }
-  export interface CheckboxRangeStartEventParams extends TableEventParams, CheckboxRangeStartParams { }
+  export interface CheckboxRangeStartEventParams<D = VxeTableDataRow> extends TableEventParams<D>, CheckboxRangeStartParams<D> { }
 
-  export interface CheckboxRangeChangeParams extends CheckboxRangeStartParams { }
-  export interface CheckboxRangeChangeEventParams extends TableEventParams, CheckboxRangeChangeParams { }
+  export interface CheckboxRangeChangeParams<D = VxeTableDataRow> extends CheckboxRangeStartParams<D> { }
+  export interface CheckboxRangeChangeEventParams<D = VxeTableDataRow> extends TableEventParams<D>, CheckboxRangeChangeParams<D> { }
 
-  export interface CheckboxRangeEndParams extends CheckboxRangeStartParams { }
+  export interface CheckboxRangeEndParams<D = VxeTableDataRow> extends CheckboxRangeStartParams<D> { }
 
-  export interface CheckboxRangeEndEventParams extends TableEventParams, CheckboxRangeEndParams { }
+  export interface CheckboxRangeEndEventParams<D = VxeTableDataRow> extends TableEventParams<D>, CheckboxRangeEndParams<D> { }
 
-  export interface CellClickParams extends TableBaseCellParams {
+  export interface CellClickParams<D = VxeTableDataRow> extends TableBaseCellParams<D> {
     triggerRadio: boolean
     triggerCheckbox: boolean
     triggerTreeNode: boolean
     triggerExpandNode: boolean
   }
-  export interface CellClickEventParams extends TableEventParams, CellClickParams { }
+  export interface CellClickEventParams<D = VxeTableDataRow> extends TableEventParams<D>, CellClickParams<D> { }
 
-  export interface CellDblclickParams extends CellClickParams, CellClickParams { }
-  export interface CellDblclickEventParams extends TableEventParams, CellDblclickParams { }
+  export interface CellDblclickParams<D = VxeTableDataRow> extends TableEventParams<D>, CellClickParams<D> { }
+  export interface CellDblclickEventParams<D = VxeTableDataRow> extends TableEventParams<D>, CellDblclickParams<D> { }
 
-  export interface CellMenuParams extends TableBaseCellParams { }
-  export interface CellMenuEventParams extends TableEventParams, CellMenuParams { }
+  export interface CellMenuParams<D = VxeTableDataRow> extends TableBaseCellParams<D> { }
+  export interface CellMenuEventParams<D = VxeTableDataRow> extends TableEventParams<D>, CellMenuParams<D> { }
 
-  export interface CellMouseenterParams extends TableBaseCellParams { }
-  export interface CellMouseenterEventParams extends TableEventParams, CellMouseenterParams { }
+  export interface CellMouseenterParams<D = VxeTableDataRow> extends TableBaseCellParams<D> { }
+  export interface CellMouseenterEventParams<D = VxeTableDataRow> extends TableEventParams<D>, CellMouseenterParams<D> { }
 
-  export interface CellMouseleaveParams extends TableBaseCellParams { }
-  export interface CellMouseleaveEventParams extends TableEventParams, CellMouseleaveParams { }
+  export interface CellMouseleaveParams<D = VxeTableDataRow> extends TableBaseCellParams<D> { }
+  export interface CellMouseleaveEventParams<D = VxeTableDataRow> extends TableEventParams<D>, CellMouseleaveParams<D> { }
 
-  export interface HeaderCellClickParams extends TableBaseHeaderCellParams {
+  export interface HeaderCellClickParams<D = VxeTableDataRow> extends TableBaseHeaderCellParams<D> {
     triggerResizable: boolean
     triggerSort: boolean
     triggerFilter: boolean
   }
-  export interface HeaderCellClickEventParams extends TableEventParams, HeaderCellClickParams { }
+  export interface HeaderCellClickEventParams<D = VxeTableDataRow> extends TableEventParams<D>, HeaderCellClickParams<D> { }
 
-  export interface HeaderCellDblclickParams extends TableBaseHeaderCellParams { }
-  export interface HeaderCellDblclickEventParams extends TableEventParams, HeaderCellDblclickParams { }
+  export interface HeaderCellDblclickParams<D = VxeTableDataRow> extends TableBaseHeaderCellParams<D> { }
+  export interface HeaderCellDblclickEventParams<D = VxeTableDataRow> extends TableEventParams<D>, HeaderCellDblclickParams<D> { }
 
-  export interface HeaderCellMenuParams extends TableBaseHeaderCellParams { }
-  export interface HeaderCellMenuEventParams extends TableEventParams, HeaderCellMenuParams { }
+  export interface HeaderCellMenuParams<D = VxeTableDataRow> extends TableBaseHeaderCellParams<D> { }
+  export interface HeaderCellMenuEventParams<D = VxeTableDataRow> extends TableEventParams<D>, HeaderCellMenuParams<D> { }
 
-  export interface FooterCellClickParams extends TableBaseFooterCellParams { }
-  export interface FooterCellClickEventParams extends TableEventParams, FooterCellClickParams { }
+  export interface FooterCellClickParams<D = VxeTableDataRow> extends TableBaseFooterCellParams<D> { }
+  export interface FooterCellClickEventParams<D = VxeTableDataRow> extends TableEventParams<D>, FooterCellClickParams<D> { }
 
-  export interface FooterCellDblclickParams extends TableBaseFooterCellParams { }
-  export interface FooterCellDblclickEventParams extends TableEventParams, FooterCellDblclickParams { }
+  export interface FooterCellDblclickParams<D = VxeTableDataRow> extends TableBaseFooterCellParams<D> { }
+  export interface FooterCellDblclickEventParams<D = VxeTableDataRow> extends TableEventParams<D>, FooterCellDblclickParams<D> { }
 
-  export interface FooterCellMenuParams extends TableBaseFooterCellParams { }
-  export interface FooterCellMenuEventParams extends TableEventParams, FooterCellMenuParams { }
+  export interface FooterCellMenuParams<D = VxeTableDataRow> extends TableBaseFooterCellParams<D> { }
+  export interface FooterCellMenuEventParams<D = VxeTableDataRow> extends TableEventParams<D>, FooterCellMenuParams<D> { }
 
-  export interface SortCheckedParams {
-    column: VxeTableDefines.ColumnInfo
+  export interface SortCheckedParams<D = VxeTableDataRow> {
+    column: VxeTableDefines.ColumnInfo<D>
     field: VxeColumnPropTypes.Field
     property: VxeColumnPropTypes.Field
     order: VxeTablePropTypes.SortOrder
     sortTime: number
   }
-  export interface SortChangeParams extends SortCheckedParams {
+  export interface SortChangeParams<D = VxeTableDataRow> extends SortCheckedParams<D> {
     sortList: SortCheckedParams[]
   }
-  export interface SortChangeEventParams extends TableEventParams, SortChangeParams { }
+  export interface SortChangeEventParams<D = VxeTableDataRow> extends TableEventParams<D>, SortChangeParams<D> { }
 
-  export interface FilterCheckedParams {
-    column: VxeTableDefines.ColumnInfo
+  export interface FilterCheckedParams<D = VxeTableDataRow> {
+    column: VxeTableDefines.ColumnInfo<D>
     field: VxeColumnPropTypes.Field
     property: VxeColumnPropTypes.Field
     values: any[]
     datas: any[]
   }
-  export interface FilterChangeParams extends FilterCheckedParams {
-    filterList: FilterCheckedParams[]
+  export interface FilterChangeParams<D = VxeTableDataRow> extends FilterCheckedParams<D> {
+    filterList: FilterCheckedParams<D>[]
   }
-  export interface FilterChangeEventParams extends TableEventParams, FilterChangeParams { }
+  export interface FilterChangeEventParams<D = VxeTableDataRow> extends TableEventParams<D>, FilterChangeParams<D> { }
 
-  export interface FilterVisibleParams {
-    column: VxeTableDefines.ColumnInfo
+  export interface FilterVisibleParams<D = VxeTableDataRow> {
+    column: VxeTableDefines.ColumnInfo<D>
     field: VxeColumnPropTypes.Field
     property: VxeColumnPropTypes.Field
-    filterList: FilterCheckedParams[]
+    filterList: FilterCheckedParams<D>[]
     visible: boolean
   }
-  export interface FilterVisibleEventParams extends TableEventParams, FilterVisibleParams { }
+  export interface FilterVisibleEventParams<D = VxeTableDataRow> extends TableEventParams<D>, FilterVisibleParams<D> { }
 
-  export interface ResizableChangeParams extends TableBaseHeaderCellParams { }
-  export interface ResizableChangeEventParams extends TableEventParams, ResizableChangeParams {
+  export interface ResizableChangeParams<D = VxeTableDataRow> extends TableBaseHeaderCellParams<D> { }
+  export interface ResizableChangeEventParams<D = VxeTableDataRow> extends TableEventParams<D>, ResizableChangeParams<D> {
     resizeWidth: number
   }
 
-  export interface ToggleRowExpandParams extends TableBaseCellParams { }
-  export interface ToggleRowExpandEventParams extends TableEventParams, ToggleRowExpandParams { }
+  export interface ToggleRowExpandParams<D = VxeTableDataRow> extends TableBaseCellParams<D> { }
+  export interface ToggleRowExpandEventParams<D = VxeTableDataRow> extends TableEventParams<D>, ToggleRowExpandParams { }
 
-  export interface ToggleTreeExpandParams extends TableBaseCellParams { }
-  export interface ToggleTreeExpandEventParams extends TableEventParams, ToggleTreeExpandParams { }
+  export interface ToggleTreeExpandParams<D = VxeTableDataRow> extends TableBaseCellParams<D> { }
+  export interface ToggleTreeExpandEventParams<D = VxeTableDataRow> extends TableEventParams<D>, ToggleTreeExpandParams<D> { }
 
-  export interface MenuClickParams extends TableBaseCellParams {
+  export interface MenuClickParams<D = VxeTableDataRow> extends TableBaseCellParams<D> {
     menu: VxeTableDefines.MenuFirstOption | VxeTableDefines.MenuChildOption
     type: string
   }
-  export interface MenuClickEventParams extends TableEventParams, MenuClickParams { }
+  export interface MenuClickEventParams<D = VxeTableDataRow> extends TableEventParams<D>, MenuClickParams<D> { }
 
-  export interface EditClosedParams extends TableBaseCellParams { }
-  export interface EditClosedEventParams extends TableEventParams, EditClosedParams { }
+  export interface EditClosedParams<D = VxeTableDataRow> extends TableBaseCellParams<D> { }
+  export interface EditClosedEventParams<D = VxeTableDataRow> extends TableEventParams<D>, EditClosedParams<D> { }
 
-  export interface EditActivedParams extends TableBaseCellParams { }
-  export interface EditActivedEventParams extends TableEventParams, EditActivedParams { }
+  export interface EditActivedParams<D = VxeTableDataRow> extends TableBaseCellParams<D> { }
+  export interface EditActivedEventParams<D = VxeTableDataRow> extends TableEventParams<D>, EditActivedParams<D> { }
 
-  export interface EditDisabledParams extends TableBaseCellParams { }
-  export interface EditDisabledEventParams extends TableEventParams, EditDisabledParams { }
+  export interface EditDisabledParams<D = VxeTableDataRow> extends TableBaseCellParams<D> { }
+  export interface EditDisabledEventParams<D = VxeTableDataRow> extends TableEventParams<D>, EditDisabledParams<D> { }
 
-  export interface ValidErrorParams extends TableBaseCellParams {
+  export interface ValidErrorParams<D = VxeTableDataRow> extends TableBaseCellParams<D> {
     rule: any
   }
-  export interface ValidErrorEventParams extends TableEventParams, ValidErrorParams { }
+  export interface ValidErrorEventParams<D = VxeTableDataRow> extends TableEventParams<D>, ValidErrorParams<D> { }
 
   export interface ScrollParams {
     type: string
@@ -2573,131 +2610,131 @@ export namespace VxeTableDefines {
     isX: boolean
     isY: boolean
   }
-  export interface ScrollEventParams extends TableEventParams, ScrollParams {
+  export interface ScrollEventParams<D = VxeTableDataRow> extends TableEventParams<D>, ScrollParams {
     target: HTMLDivElement
   }
 
   export interface CustomParams {
     type: string
   }
-  export interface CustomEventParams extends TableEventParams, CustomParams { }
+  export interface CustomEventParams<D = VxeTableDataRow> extends TableEventParams<D>, CustomParams { }
 }
 
-export interface VxeTableEventProps {
-  onKeydownStart?: VxeTableEvents.KeydownStart
-  onKeydown?: VxeTableEvents.Keydown
-  onKeydownEnd?: VxeTableEvents.KeydownEnd
-  onPaste?: VxeTableEvents.Paste
-  onCopy?: VxeTableEvents.Copy
-  onCut?: VxeTableEvents.Cut
-  onCurrentChange?: VxeTableEvents.CurrentChange
-  onRadioChange?: VxeTableEvents.RadioChange
-  onCheckboxChange?: VxeTableEvents.CheckboxChange
-  onCheckboxAll?: VxeTableEvents.CheckboxAll
-  onCheckboxRangeStart?: VxeTableEvents.CheckboxRangeStart
-  onCheckboxRangeChange?: VxeTableEvents.CheckboxRangeChange
-  onCheckboxRangeEnd?: VxeTableEvents.CheckboxRangeEnd
-  onCellClick?: VxeTableEvents.CellClick
-  onCellDblclick?: VxeTableEvents.CellDblclick
-  onCellMenu?: VxeTableEvents.CellMenu
-  onCellMouseenter?: VxeTableEvents.CellMouseenter
-  onCellMouseleave?: VxeTableEvents.CellMouseleave
-  onHeaderCellClick?: VxeTableEvents.HeaderCellClick
-  onHeaderCellDblclick?: VxeTableEvents.HeaderCellDblclick
-  onHeaderCellMenu?: VxeTableEvents.HeaderCellMenu
-  onFooterCellClick?: VxeTableEvents.FooterCellClick
-  onFooterCellDblclick?: VxeTableEvents.FooterCellDblclick
-  onFooterCellMenu?: VxeTableEvents.FooterCellMenu
-  onSortChange?: VxeTableEvents.SortChange
-  onFilterChange?: VxeTableEvents.FilterChange
-  onFilterVisible?: VxeTableEvents.FilterVisible
-  onResizableChange?: VxeTableEvents.ResizableChange
-  onToggleRowExpand?: VxeTableEvents.ToggleRowExpand
-  onToggleTreeExpand?: VxeTableEvents.ToggleTreeExpand
-  onMenuClick?: VxeTableEvents.MenuClick
-  onEditClosed?: VxeTableEvents.EditClosed
-  onEditActived?: VxeTableEvents.EditActived
-  onEditDisabled?: VxeTableEvents.EditDisabled
-  onValidError?: VxeTableEvents.ValidError
-  onScroll?: VxeTableEvents.Scroll
-  onCustom?: VxeTableEvents.Custom
+export interface VxeTableEventProps<D = VxeTableDataRow> {
+  onKeydownStart?: VxeTableEvents.KeydownStart<D>
+  onKeydown?: VxeTableEvents.Keydown<D>
+  onKeydownEnd?: VxeTableEvents.KeydownEnd<D>
+  onPaste?: VxeTableEvents.Paste<D>
+  onCopy?: VxeTableEvents.Copy<D>
+  onCut?: VxeTableEvents.Cut<D>
+  onCurrentChange?: VxeTableEvents.CurrentChange<D>
+  onRadioChange?: VxeTableEvents.RadioChange<D>
+  onCheckboxChange?: VxeTableEvents.CheckboxChange<D>
+  onCheckboxAll?: VxeTableEvents.CheckboxAll<D>
+  onCheckboxRangeStart?: VxeTableEvents.CheckboxRangeStart<D>
+  onCheckboxRangeChange?: VxeTableEvents.CheckboxRangeChange<D>
+  onCheckboxRangeEnd?: VxeTableEvents.CheckboxRangeEnd<D>
+  onCellClick?: VxeTableEvents.CellClick<D>
+  onCellDblclick?: VxeTableEvents.CellDblclick<D>
+  onCellMenu?: VxeTableEvents.CellMenu<D>
+  onCellMouseenter?: VxeTableEvents.CellMouseenter<D>
+  onCellMouseleave?: VxeTableEvents.CellMouseleave<D>
+  onHeaderCellClick?: VxeTableEvents.HeaderCellClick<D>
+  onHeaderCellDblclick?: VxeTableEvents.HeaderCellDblclick<D>
+  onHeaderCellMenu?: VxeTableEvents.HeaderCellMenu<D>
+  onFooterCellClick?: VxeTableEvents.FooterCellClick<D>
+  onFooterCellDblclick?: VxeTableEvents.FooterCellDblclick<D>
+  onFooterCellMenu?: VxeTableEvents.FooterCellMenu<D>
+  onSortChange?: VxeTableEvents.SortChange<D>
+  onFilterChange?: VxeTableEvents.FilterChange<D>
+  onFilterVisible?: VxeTableEvents.FilterVisible<D>
+  onResizableChange?: VxeTableEvents.ResizableChange<D>
+  onToggleRowExpand?: VxeTableEvents.ToggleRowExpand<D>
+  onToggleTreeExpand?: VxeTableEvents.ToggleTreeExpand<D>
+  onMenuClick?: VxeTableEvents.MenuClick<D>
+  onEditClosed?: VxeTableEvents.EditClosed<D>
+  onEditActived?: VxeTableEvents.EditActived<D>
+  onEditDisabled?: VxeTableEvents.EditDisabled<D>
+  onValidError?: VxeTableEvents.ValidError<D>
+  onScroll?: VxeTableEvents.Scroll<D>
+  onCustom?: VxeTableEvents.Custom<D>
 }
 
-export interface VxeTableListeners {
-  keydownStart?: VxeTableEvents.KeydownStart
-  keydown?: VxeTableEvents.Keydown
-  keydownEnd?: VxeTableEvents.KeydownEnd
-  paste?: VxeTableEvents.Paste
-  copy?: VxeTableEvents.Copy
-  cut?: VxeTableEvents.Cut
-  currentChange?: VxeTableEvents.CurrentChange
-  radioChange?: VxeTableEvents.RadioChange
-  checkboxChange?: VxeTableEvents.CheckboxChange
-  checkboxAll?: VxeTableEvents.CheckboxAll
-  checkboxRangeStart?: VxeTableEvents.CheckboxRangeStart
-  checkboxRangeChange?: VxeTableEvents.CheckboxRangeChange
-  checkboxRangeEnd?: VxeTableEvents.CheckboxRangeEnd
-  cellClick?: VxeTableEvents.CellClick
-  cellDblclick?: VxeTableEvents.CellDblclick
-  cellMenu?: VxeTableEvents.CellMenu
-  cellMouseenter?: VxeTableEvents.CellMouseenter
-  cellMouseleave?: VxeTableEvents.CellMouseleave
-  headerCellClick?: VxeTableEvents.HeaderCellClick
-  headerCellDblclick?: VxeTableEvents.HeaderCellDblclick
-  headerCellMenu?: VxeTableEvents.HeaderCellMenu
-  footerCellClick?: VxeTableEvents.FooterCellClick
-  footerCellDblclick?: VxeTableEvents.FooterCellDblclick
-  footerCellMenu?: VxeTableEvents.FooterCellMenu
-  sortChange?: VxeTableEvents.SortChange
-  filterChange?: VxeTableEvents.FilterChange
-  resizableChange?: VxeTableEvents.ResizableChange
-  toggleRowExpand?: VxeTableEvents.ToggleRowExpand
-  toggleTreeExpand?: VxeTableEvents.ToggleTreeExpand
-  menuClick?: VxeTableEvents.MenuClick
-  editClosed?: VxeTableEvents.EditClosed
-  editActived?: VxeTableEvents.EditActived
-  editDisabled?: VxeTableEvents.EditDisabled
-  validError?: VxeTableEvents.ValidError
-  scroll?: VxeTableEvents.Scroll
-  custom?: VxeTableEvents.Custom
+export interface VxeTableListeners<D = VxeTableDataRow> {
+  keydownStart?: VxeTableEvents.KeydownStart<D>
+  keydown?: VxeTableEvents.Keydown<D>
+  keydownEnd?: VxeTableEvents.KeydownEnd<D>
+  paste?: VxeTableEvents.Paste<D>
+  copy?: VxeTableEvents.Copy<D>
+  cut?: VxeTableEvents.Cut<D>
+  currentChange?: VxeTableEvents.CurrentChange<D>
+  radioChange?: VxeTableEvents.RadioChange<D>
+  checkboxChange?: VxeTableEvents.CheckboxChange<D>
+  checkboxAll?: VxeTableEvents.CheckboxAll<D>
+  checkboxRangeStart?: VxeTableEvents.CheckboxRangeStart<D>
+  checkboxRangeChange?: VxeTableEvents.CheckboxRangeChange<D>
+  checkboxRangeEnd?: VxeTableEvents.CheckboxRangeEnd<D>
+  cellClick?: VxeTableEvents.CellClick<D>
+  cellDblclick?: VxeTableEvents.CellDblclick<D>
+  cellMenu?: VxeTableEvents.CellMenu<D>
+  cellMouseenter?: VxeTableEvents.CellMouseenter<D>
+  cellMouseleave?: VxeTableEvents.CellMouseleave<D>
+  headerCellClick?: VxeTableEvents.HeaderCellClick<D>
+  headerCellDblclick?: VxeTableEvents.HeaderCellDblclick<D>
+  headerCellMenu?: VxeTableEvents.HeaderCellMenu<D>
+  footerCellClick?: VxeTableEvents.FooterCellClick<D>
+  footerCellDblclick?: VxeTableEvents.FooterCellDblclick<D>
+  footerCellMenu?: VxeTableEvents.FooterCellMenu<D>
+  sortChange?: VxeTableEvents.SortChange<D>
+  filterChange?: VxeTableEvents.FilterChange<D>
+  resizableChange?: VxeTableEvents.ResizableChange<D>
+  toggleRowExpand?: VxeTableEvents.ToggleRowExpand<D>
+  toggleTreeExpand?: VxeTableEvents.ToggleTreeExpand<D>
+  menuClick?: VxeTableEvents.MenuClick<D>
+  editClosed?: VxeTableEvents.EditClosed<D>
+  editActived?: VxeTableEvents.EditActived<D>
+  editDisabled?: VxeTableEvents.EditDisabled<D>
+  validError?: VxeTableEvents.ValidError<D>
+  scroll?: VxeTableEvents.Scroll<D>
+  custom?: VxeTableEvents.Custom<D>
 }
 
 export namespace VxeTableEvents {
-  export type KeydownStart = (params: VxeTableDefines.KeydownStartEventParams) => void
-  export type Keydown = (params: VxeTableDefines.KeydownEventParams) => void
-  export type KeydownEnd = (params: VxeTableDefines.KeydownEndEventParams) => void
-  export type Paste = (params: VxeTableDefines.PasteEventParams) => void
-  export type Copy = (params: VxeTableDefines.CopyEventParams) => void
-  export type Cut = (params: VxeTableDefines.CutEventParams) => void
-  export type CurrentChange = (params: VxeTableDefines.CurrentChangeEventParams) => void
-  export type RadioChange = (params: VxeTableDefines.RadioChangeEventParams) => void
-  export type CheckboxChange = (params: VxeTableDefines.CheckboxChangeEventParams) => void
-  export type CheckboxAll = (params: VxeTableDefines.CheckboxAllEventParams) => void
-  export type CheckboxRangeStart = (params: VxeTableDefines.CheckboxRangeStartEventParams) => void
-  export type CheckboxRangeChange = (params: VxeTableDefines.CheckboxRangeChangeEventParams) => void
-  export type CheckboxRangeEnd = (params: VxeTableDefines.CheckboxRangeEndEventParams) => void
-  export type CellClick = (params: VxeTableDefines.CellClickEventParams) => void
-  export type CellDblclick = (params: VxeTableDefines.CellDblclickEventParams) => void
-  export type CellMenu = (params: VxeTableDefines.CellMenuEventParams) => void
-  export type CellMouseenter = (params: VxeTableDefines.CellMouseenterEventParams) => void
-  export type CellMouseleave = (params: VxeTableDefines.CellMouseleaveEventParams) => void
-  export type HeaderCellClick = (params: VxeTableDefines.HeaderCellClickEventParams) => void
-  export type HeaderCellDblclick = (params: VxeTableDefines.HeaderCellDblclickEventParams) => void
-  export type HeaderCellMenu = (params: VxeTableDefines.HeaderCellMenuEventParams) => void
-  export type FooterCellClick = (params: VxeTableDefines.FooterCellClickEventParams) => void
-  export type FooterCellDblclick = (params: VxeTableDefines.FooterCellDblclickEventParams) => void
-  export type FooterCellMenu = (params: VxeTableDefines.FooterCellMenuEventParams) => void
-  export type SortChange = (params: VxeTableDefines.SortChangeEventParams) => void
-  export type FilterChange = (params: VxeTableDefines.FilterChangeEventParams) => void
-  export type FilterVisible = (params: VxeTableDefines.FilterVisibleEventParams) => void
-  export type ResizableChange = (params: VxeTableDefines.ResizableChangeEventParams) => void
-  export type ToggleRowExpand = (params: VxeTableDefines.ToggleRowExpandEventParams) => void
-  export type ToggleTreeExpand = (params: VxeTableDefines.ToggleTreeExpandEventParams) => void
-  export type MenuClick = (params: VxeTableDefines.MenuClickEventParams) => void
-  export type EditClosed = (params: VxeTableDefines.EditClosedEventParams) => void
-  export type EditActived = (params: VxeTableDefines.EditActivedEventParams) => void
-  export type EditDisabled = (params: VxeTableDefines.EditDisabledEventParams) => void
-  export type ValidError = (params: VxeTableDefines.ValidErrorEventParams) => void
-  export type Scroll = (params: VxeTableDefines.ScrollEventParams) => void
-  export type Custom = (params: VxeTableDefines.CustomEventParams) => void
+  export type KeydownStart<D = any> = (params: VxeTableDefines.KeydownStartEventParams<D>) => void
+  export type Keydown<D = any> = (params: VxeTableDefines.KeydownEventParams<D>) => void
+  export type KeydownEnd<D = any> = (params: VxeTableDefines.KeydownEndEventParams<D>) => void
+  export type Paste<D = any> = (params: VxeTableDefines.PasteEventParams<D>) => void
+  export type Copy<D = any> = (params: VxeTableDefines.CopyEventParams<D>) => void
+  export type Cut<D = any> = (params: VxeTableDefines.CutEventParams<D>) => void
+  export type CurrentChange<D = any> = (params: VxeTableDefines.CurrentChangeEventParams<D>) => void
+  export type RadioChange<D = any> = (params: VxeTableDefines.RadioChangeEventParams<D>) => void
+  export type CheckboxChange<D = any> = (params: VxeTableDefines.CheckboxChangeEventParams<D>) => void
+  export type CheckboxAll<D = any> = (params: VxeTableDefines.CheckboxAllEventParams<D>) => void
+  export type CheckboxRangeStart<D = any> = (params: VxeTableDefines.CheckboxRangeStartEventParams<D>) => void
+  export type CheckboxRangeChange<D = any> = (params: VxeTableDefines.CheckboxRangeChangeEventParams<D>) => void
+  export type CheckboxRangeEnd<D = any> = (params: VxeTableDefines.CheckboxRangeEndEventParams<D>) => void
+  export type CellClick<D = any> = (params: VxeTableDefines.CellClickEventParams<D>) => void
+  export type CellDblclick<D = any> = (params: VxeTableDefines.CellDblclickEventParams<D>) => void
+  export type CellMenu<D = any> = (params: VxeTableDefines.CellMenuEventParams<D>) => void
+  export type CellMouseenter<D = any> = (params: VxeTableDefines.CellMouseenterEventParams<D>) => void
+  export type CellMouseleave<D = any> = (params: VxeTableDefines.CellMouseleaveEventParams<D>) => void
+  export type HeaderCellClick<D = any> = (params: VxeTableDefines.HeaderCellClickEventParams<D>) => void
+  export type HeaderCellDblclick<D = any> = (params: VxeTableDefines.HeaderCellDblclickEventParams<D>) => void
+  export type HeaderCellMenu<D = any> = (params: VxeTableDefines.HeaderCellMenuEventParams<D>) => void
+  export type FooterCellClick<D = any> = (params: VxeTableDefines.FooterCellClickEventParams<D>) => void
+  export type FooterCellDblclick<D = any> = (params: VxeTableDefines.FooterCellDblclickEventParams<D>) => void
+  export type FooterCellMenu<D = any> = (params: VxeTableDefines.FooterCellMenuEventParams<D>) => void
+  export type SortChange<D = any> = (params: VxeTableDefines.SortChangeEventParams<D>) => void
+  export type FilterChange<D = any> = (params: VxeTableDefines.FilterChangeEventParams<D>) => void
+  export type FilterVisible<D = any> = (params: VxeTableDefines.FilterVisibleEventParams<D>) => void
+  export type ResizableChange<D = any> = (params: VxeTableDefines.ResizableChangeEventParams<D>) => void
+  export type ToggleRowExpand<D = any> = (params: VxeTableDefines.ToggleRowExpandEventParams<D>) => void
+  export type ToggleTreeExpand<D = any> = (params: VxeTableDefines.ToggleTreeExpandEventParams<D>) => void
+  export type MenuClick<D = any> = (params: VxeTableDefines.MenuClickEventParams<D>) => void
+  export type EditClosed<D = any> = (params: VxeTableDefines.EditClosedEventParams<D>) => void
+  export type EditActived<D = any> = (params: VxeTableDefines.EditActivedEventParams<D>) => void
+  export type EditDisabled<D = any> = (params: VxeTableDefines.EditDisabledEventParams<D>) => void
+  export type ValidError<D = any> = (params: VxeTableDefines.ValidErrorEventParams<D>) => void
+  export type Scroll<D = any> = (params: VxeTableDefines.ScrollEventParams<D>) => void
+  export type Custom<D = any> = (params: VxeTableDefines.CustomEventParams<D>) => void
 }