vxe-table/types/table.d.ts

import { RenderFunction, SetupContext, Ref, ComputedRef, ComponentPublicInstance, ComponentInternalInstance, VNode } from 'vue'
import { VXEComponent, VxeComponentBase, VxeEvent, SizeType, ValueOf, VNodeStyle, SlotVNodeType } from './component'
import { VxeTableProEmits, VxeTableProDefines } from './plugins/pro'
import { VxeColumnPropTypes, VxeColumnProps } from './column'
import { VXETableSetupOptions, VxeGlobalRendererHandles } from './v-x-e-table'
import { VxeToolbarConstructor, VxeToolbarInstance } from './toolbar'
import { VxeTooltipInstance } from './tooltip'
import { VxeGridConstructor } from './grid'
import { VxeMenuPanelInstance } from './menu'

/* eslint-disable no-use-before-define */

/**
 * 组件 - 表格
 * @example import { VxeTable } from 'vxe-table'
 */
export const VxeTable: VXEComponent<VxeTableProps, VxeTableEventProps>
/**
 * 组件 - 表格
 */
export const Table: VXEComponent<VxeTableProps, VxeTableEventProps>

export type VxeTableInstance = ComponentPublicInstance<VxeTableProps, VxeTableConstructor>

export interface VxeTableConstructor extends VxeComponentBase, VxeTableMethods {
  props: Readonly<VxeTableProps>
  context: SetupContext<VxeTableEmits>
  instance: ComponentInternalInstance
  reactData: TableReactData
  internalData: TableInternalData
  getRefMaps(): TablePrivateRef
  getComputeMaps(): TablePrivateComputed
  renderVN: RenderFunction

  xegrid: VxeGridConstructor | null
}

export interface TablePrivateRef {
  refElem: Ref<HTMLDivElement>
  refTooltip: Ref<VxeTooltipInstance>
  refValidTooltip: Ref<VxeTooltipInstance>
  refTableFilter: Ref<ComponentPublicInstance>
  refTableMenu: Ref<VxeMenuPanelInstance>
  refTableHeader: Ref<ComponentPublicInstance>
  refTableBody: Ref<ComponentPublicInstance>
  refTableFooter: Ref<ComponentPublicInstance>
  refTableLeftHeader: Ref<ComponentPublicInstance>
  refTableLeftBody: Ref<ComponentPublicInstance>
  refTableLeftFooter: Ref<ComponentPublicInstance>
  refTableRightHeader: Ref<ComponentPublicInstance>
  refTableRightBody: Ref<ComponentPublicInstance>
  refTableRightFooter: Ref<ComponentPublicInstance>
  refLeftContainer: Ref<HTMLDivElement>
  refRightContainer: Ref<HTMLDivElement>
  refCellResizeBar: Ref<HTMLDivElement>
}
export interface VxeTablePrivateRef extends TablePrivateRef { }

export interface TablePrivateComputed {
  computeSize: ComputedRef<VxeTablePropTypes.Size>
  computeValidOpts: ComputedRef<VxeTablePropTypes.ValidOpts>
  computeSXOpts: ComputedRef<VxeTablePropTypes.SXOpts>
  computeSYOpts: ComputedRef<VxeTablePropTypes.SYOpts>
  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>
  computeMouseOpts: ComputedRef<VxeTablePropTypes.MouseOpts>
  computeAreaOpts: ComputedRef<VxeTablePropTypes.AreaOpts>
  computeKeyboardOpts: ComputedRef<VxeTablePropTypes.KeyboardOpts>
  computeClipOpts: ComputedRef<VxeTablePropTypes.ClipOpts>
  computeFNROpts: ComputedRef<VxeTablePropTypes.FNROpts>
  computeHeaderMenu: ComputedRef<VxeTableDefines.MenuFirstOption>
  computeBodyMenu: ComputedRef<VxeTableDefines.MenuFirstOption>
  computeFooterMenu: ComputedRef<VxeTableDefines.MenuFirstOption>
  computeIsMenu: ComputedRef<boolean>
  computeMenuOpts: ComputedRef<VxeTablePropTypes.MenuConfig>
  computeExportOpts: ComputedRef<VxeTablePropTypes.ExportOpts>
  computeImportOpts: ComputedRef<VxeTablePropTypes.ImportOpts>
  computePrintOpts: ComputedRef<VxeTablePropTypes.PrintOpts>
  computeExpandOpts: ComputedRef<VxeTablePropTypes.ExpandOpts>
  computeTreeOpts: ComputedRef<VxeTablePropTypes.TreeOpts>
  computeEmptyOpts: ComputedRef<VxeTablePropTypes.EmptyOpts>
  computeLoadingOpts: ComputedRef<VxeTablePropTypes.LoadingOpts>
  computeCustomOpts: ComputedRef<VxeTablePropTypes.CustomOpts>
  computeIsAllCheckboxDisabled: ComputedRef<boolean>
}

export type VxeTablePrivateComputed = TablePrivateComputed

export interface TableMethods extends TablePublicMethods {
  dispatchEvent(type: ValueOf<VxeTableEmits>, params: any, evnt: Event | null): void
}

export interface TablePublicMethods {
  /**
   * 手动清除表格所有条件，还原到初始状态
   * 对于增删改查的场景中可能会用到，比如在数据保存之后清除表格缓存
   */
  clearAll(): Promise<any>
  /**
   * 该方法已废弃！！！
   * 同步 data 数据；如果用了该方法，那么组件将不再记录增删改的状态，只能自行实现对应逻辑
   * 对于某些特殊的场景，比如深层树节点元素发生变动时可能会用到
   * @deprecated
   */
  syncData(): Promise<any>
  /**
   * 手动处理数据，用于手动排序与筛选
   * 对于手动更改了排序、筛选...等条件后需要重新处理数据时可能会用到
   */
  updateData(): Promise<any>
  /**
   * 加载数据
   * @param data 数据
   */
  loadData(data: any[]): Promise<any>
  /**
   * 加载数据并恢复到初始状态
   * @param data 数据
   */
  reloadData(data: any[]): Promise<any>
  /**
   * 局部加载行数据并恢复到初始状态
   * @param rows 行对象
   * @param record 新数据
   * @param field 指定字段名
   */
  reloadRow(rows: any | any[], record?: any, field?: string): Promise<any>
  /**
   * 用于树结构，给行数据加载子节点
   * @param row 行对象
   * @param children 子节点
   */
  loadTreeChildren(row: any, children: any[]): Promise<any[]>
  /**
   * 加载列配置
   * @param columns 列对象
   */
  loadColumn(columns: (VxeTableDefines.ColumnOptions | VxeTableDefines.ColumnInfo)[]): Promise<any>
  /**
   * 加载列配置并恢复到初始状态
   * @param columns 列对象
   */
  reloadColumn(columns: (VxeTableDefines.ColumnOptions | VxeTableDefines.ColumnInfo)[]): Promise<any>
  /**
   * 根据 tr 元素获取对应的 row 信息
   * @param tr 行节点元素
   */
  getRowNode(trElem: HTMLElement): {
    rowid: string
    item: any
    items: any[]
    index: number
    parent?: any
  } | null
  /**
   * 根据 th/td 元素获取对应的 column 信息
   * @param cell 单元格节点元素
   */
  getColumnNode(cellElem: HTMLElement): {
    colid: string
    item: VxeTableDefines.ColumnInfo
    items: VxeTableDefines.ColumnInfo[]
    index: number
    parent?: VxeTableDefines.ColumnInfo
  } | null
  /**
   * 根据 row 获取行的序号
   * @param row 行对象
   */
  getRowSeq(row: any): string | number
  /**
   * 根据 row 获取相对于 data 中的索引
   * @param row 行对象
   */
  getRowIndex(row: any): number
  /**
   * 根据 row 获取相对于当前数据中的索引
   * @param row 行对象
   */
  getVTRowIndex(row: any): number
  /**
   * 根据 row 获取渲染中的虚拟索引
   * @param row 行对象
   */
  getVMRowIndex(row: any): number
  /**
   * 根据 column 获取相对于 columns 中的索引
   * @param column 列对象
   */
  getColumnIndex(column: VxeTableDefines.ColumnInfo): number
  /**
   * 根据 column 获取相对于当前表格列中的索引
   * @param column 列对象
   */
  getVTColumnIndex(column: VxeTableDefines.ColumnInfo): number
  /**
   * 根据 column 获取渲染中的虚拟索引
   * @param column 列对象
   */
  getVMColumnIndex(column: VxeTableDefines.ColumnInfo): number
  /**
   * 创建 data 对象
   * 对于某些特殊场景可能会用到，会自动对数据的字段名进行检测，如果不存在就自动定义
   * @param records 数据
   */
  createData(records: any[]): Promise<any[]>
  /**
   * 创建 Row|Rows 对象
   * 对于某些特殊场景需要对数据进行手动插入时可能会用到
   * @param records 数据
   */
  createRow(records: any | any[]): Promise<any | any[]>
  /**
   * 只对 keep-source 开启有效，还原指定行 row 或者整个表格的数据
   * @param rows 指定行
   * @param field 字段名
   */
  revertData(rows?: any | any[], field?: string): Promise<any>
  /**
   * 手动清空单元格内容，如果不传参数，则清空整个表格内容，如果传了行则清空指定行内容，如果传了指定字段，则清空该字段内容
   * @param rows 指定行
   * @param field 字段名
   */
  clearData(rows?: any | any[], field?: string): Promise<any>
  /**
   * 用于 edit-config，判断行是否为新增的临时数据
   * @param row 指定行
   */
  isInsertByRow(row: any): boolean
  /**
   * 删除所有新增的临时数据
   */
  removeInsertRow(): Promise<{ row: any, rows: any[] }>
  /**
   * 只对 keep-source 开启有效，判断行数据是否发生改变
   * @param row 指定行
   * @param field 指定字段
   */
  isUpdateByRow(row: any, field?: string): boolean
  /**
   * 获取表格的可视列，也可以指定索引获取列
   * @param columnIndex 列索引
   */
  getColumns(): VxeTableDefines.ColumnInfo[]
  getColumns(columnIndex?: number): VxeTableDefines.ColumnInfo
  /**
   * 根据列的唯一主键获取列
   * @param colid 列主键
   */
  getColumnById(colid: string): VxeTableDefines.ColumnInfo | null
  /**
   * 根据列的字段名获取列
   * @param field 字段名
   */
  getColumnByField(field: string): VxeTableDefines.ColumnInfo | null
  /**
   * 获取当前表格的列
   * 收集到的全量列、全量表头列、处理条件之后的全量表头列、当前渲染中的表头列
   */
  getTableColumn(): {
    collectColumn: VxeTableDefines.ColumnInfo[]
    fullColumn: VxeTableDefines.ColumnInfo[]
    visibleColumn: VxeTableDefines.ColumnInfo[]
    tableColumn: VxeTableDefines.ColumnInfo[]
  }
  /**
   * 获取数据，和 data 的行为一致，也可以指定索引获取数据
   */
  getData(): any[]
  getData(rowIndex: number): any
  /**
   * 用于 type=checkbox，获取已选中的行数据
   */
  getCheckboxRecords(isFull?: boolean): any[]
  /**
   * 只对 tree-config 有效，获取行的父级
   */
  getParentRow (rowOrRowid: any): any | null
  /**
   * 根据行的唯一主键获取行
   * @param rowid 行主键
   */
  getRowById(rowid: string | number): any | null
  /**
   * 根据行获取行的唯一主键
   * @param row 行对象
   */
  getRowid(row: any): string
  /**
   * 获取当前表格的数据
   * 完整的全量表体数据、处理条件之后的全量表体数据、当前渲染中的表体数据、当前渲染中的表尾数据
   */
  getTableData(): {
    fullData: any[]
    visibleData: any[]
    tableData: any[]
    footerData: any[][]
  }
  /**
   * 隐藏指定列
   * @param columnOrField 列对象或字段名
   */
  hideColumn(fieldOrColumn: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo): Promise<any>
  /**
   * 显示指定列
   * @param columnOrField 列对象或字段名
   */
  showColumn(fieldOrColumn: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo): Promise<any>
  /**
   * 设置列宽
   * @param fieldOrColumn 列对象或字段名
   * @param width 宽度 %，px
   */
  setColumnWidth(fieldOrColumn: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo, width: number | string): Promise<any>
  /**
   * 获取列宽
   * @param fieldOrColumn 列对象或字段名
   */
  getColumnWidth(fieldOrColumn: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo): number;
  /**
   * 手动重置列的显示隐藏、列宽拖动的状态；如果为 true 则重置所有状态
   * 如果已关联工具栏，则会同步更新
   * @param options 可选参数
   */
  resetColumn(options?: boolean | { visible?: boolean, resizable?: boolean }): Promise<any>
  /**
   * 刷新列配置
   * 对于动态修改属性、显示/隐藏列等场景下可能会用到
   */
  refreshColumn(): Promise<any>
  /**
   * 刷新滚动操作，手动同步滚动相关位置
   * 对于某些特殊的操作，比如滚动条错位、固定列不同步
   */
  refreshScroll(): Promise<any>
  /**
   * 重新计算表格，如果传 true 则进行完整计算
   * 对于某些特殊场景可能会用到，比如隐藏的表格、重新计算列宽...等
   */
  recalculate(refull?: boolean): Promise<any>
  /**
   * 打开 tooltip 提示
   * @param target 目标元素
   * @param content 内容
   */
  openTooltip(target: HTMLElement, content: string | number): Promise<any>
  /**
   * 关闭 tooltip 提示
   */
  closeTooltip(): Promise<any>
  /**
   * 用于 type=checkbox，设置行为选中状态，第二个参数为选中与否
   * @param rows 指定行
   * @param checked 是否选中
   */
  setCheckboxRow(rows: any | any[], checked: boolean): Promise<any>
  /**
   * 用于 type=checkbox，判断列头复选框是否被选中
   */
  isAllCheckboxChecked(): boolean
  /**
   * 用于 type=checkbox，判断列头复选框是否被半选
   */
  isAllCheckboxIndeterminate(): boolean
  /**
   * 用于 type=checkbox，判断复选行数据是否勾选
   * @param row 指定行
   */
  isCheckedByCheckboxRow(row: any): boolean
  /**
   * 用于 type=checkbox，判断复选行数据是否半选
   * @param row 指定行
   */
  isIndeterminateByCheckboxRow(row: any): boolean
  /**
   * 用于 type=checkbox，切换某一行的选中状态
   * @param row 指定行
   */
  toggleCheckboxRow(row: any): Promise<any>
  /**
   * 用于 type=checkbox，设置所有行的选中状态
   * @param checked 是否选中
   */
  setAllCheckboxRow(checked: boolean): Promise<any>
  /**
   * 用于 radio-config.reserve，获取已保留选中的行数据
   */
  getRadioReserveRecord(isFull?: boolean): any[]
  /**
   * 用于 radio-config.reserve，手动清空用户保留选中的行数据
   */
  clearRadioReserve(): Promise<any>
  /**
   * 用于 checkbox-config.reserve，获取已保留选中的行数据
   */
  getCheckboxReserveRecords(isFull?: boolean): any[]
  /**
   * 用于 type=checkbox，获取半选状态的行数据
   */
  getCheckboxIndeterminateRecords(isFull?: boolean): any[]
  /**
   * 用于 checkbox-config.reserve，手动清空用户保留选中的行数据
   */
  clearCheckboxReserve(): Promise<any>
  /**
   * 用于 type=checkbox，切换所有行的选中状态
   */
  toggleAllCheckboxRow(): Promise<any>
  /**
   * 用于 type=checkbox，手动清空用户的选择
   */
  clearCheckboxRow(): Promise<any>
  /**
   * 用于 row-config.isCurrent，设置某一行为高亮状态
   * @param row 指定行
   */
  setCurrentRow(row: any): Promise<any>
  /**
   * 用于 type=radio，判断单选行数据是否勾选
   * @param row 指定行
   */
  isCheckedByRadioRow(row: any): boolean
  /**
   * 用于 type=radio，设置某一行为选中状态
   * @param row 指定行
   */
  setRadioRow(row: any): Promise<any>
  /**
   * 手动清除临时合并的单元格
   */
  clearMergeCells(): Promise<any>
  /**
   * 手动清除临时合并的表尾
   */
  clearMergeFooterItems(): Promise<any>
  /**
   * 用于 row-config.isCurrent，手动清空当前高亮的状态
   */
  clearCurrentRow(): Promise<any>
  /**
   * 用于 type=radio，手动清空用户的选择
   */
  clearRadioRow(): Promise<any>
  /**
   * 获取临时合并的单元格
   */
  getMergeCells(): VxeTableDefines.MergeInfo[]
  /**
   * 获取临时合并的表尾
   */
  getMergeFooterItems(): VxeTableDefines.MergeInfo[]
  /**
   * 用于 column-config.isCurrent，获取当前列
   */
  getCurrentColumn(): VxeTableDefines.ColumnInfo | null
  /**
   * 用于 row-config.isCurrent，获取当前行的行数据
   */
  getCurrentRecord(): any
  /**
   * 用于 type=radio，获取当已选中的行数据
   */
  getRadioRecord(isFull?: boolean): any
  /**
   * 用于 column-config.isCurrent，设置某列行为高亮状态
   * @param columnOrField 列对象或字段名
   */
  setCurrentColumn(fieldOrColumn: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo): Promise<any>
  /**
   * 用于 column-config.isCurrent，手动清空当前高亮的状态
   */
  clearCurrentColumn(): Promise<any>
  /**
   * 手动对表格进行排序
   * @param sortConfs 字段名、多列排序
   * @param order 排序方式
   */
  sort(field: string, order?: VxeTablePropTypes.SortOrder): Promise<any>
  sort(sortConfs: VxeTableDefines.SortConfs, order?: VxeTablePropTypes.SortOrder): Promise<any>
  sort(sortConfs: VxeTableDefines.SortConfs[], order?: VxeTablePropTypes.SortOrder): Promise<any>
  /**
   * 手动清空排序条件，数据会恢复成未排序的状态
   * @param columnOrField 列对象或字段名
   */
  clearSort(fieldOrColumn?: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo | null): Promise<any>
  /**
   * 判断指定列是否为排序状态，如果为空则判断所有列
   * @param columnOrField 列对象或字段名
   */
  isSort(fieldOrColumn: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo): boolean
  /**
   * 获取当前排序的列信息
   */
  getSortColumns(): VxeTableDefines.SortCheckedParams[]
  /**
   * 手动关闭筛选面板
   */
  closeFilter(): Promise<any>
  /**
   * 判断指定列是否为筛选状态，如果为空则判断所有列
   * @param columnOrField 列对象或字段名
   */
  isFilter(fieldOrColumn: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo): boolean
  /**
   * 用于 expand-config.lazy，用于懒加载展开行，判断展开行是否懒加载完成
   * @param row 指定行
   */
  isRowExpandLoaded(row: any): boolean
  /**
   * 用于 expand-config.lazy，手动清空懒加载展开行的状态，数据会恢复成未展开的状态，当再次展开时会重新加载
   */
  clearRowExpandLoaded(row: any): Promise<any>
  /**
   * 重新懒加载展开行，并展开内容
   * @param row 指定行
   */
  reloadRowExpand(row: any): Promise<any>
  /**
   * @deprecated 已废弃，请使用 reloadRowExpand
   */
  reloadExpandContent(row: any): Promise<any>
  /**
   * 用于 type=expand，切换展开行的状态
   * @param row 指定行
   */
  toggleRowExpand(row: any): Promise<any>
  /**
   * 用于 expand-config，设置所有行的展开与否
   * 如果是关闭所有行，可以使用 clearRowExpand 快速清除
   * @param checked 是否选中
   */
  setAllRowExpand(checked: boolean): Promise<any>
  /**
   * 用于 expand-config，设置展开行，二个参数设置这一行展开与否
   * @param rows 指定行
   * @param checked 是否选中
   */
  setRowExpand(rows: any | any[], checked: boolean): Promise<any>
  /**
   * 用于 expand-config，判断行是否为展开状态
   * @param row 指定行
   */
  isExpandByRow(row: any): boolean
  /**
   * 用于 type=expand，手动清空展开行状态，数据会恢复成未展开的状态
   */
  clearRowExpand(): Promise<any>
  /**
   * 用于 type=expand，手动清空用户保留行的展开状态
   */
  clearRowExpandReserve(): Promise<any>
  /**
   * 用于 expand-config，用于展开行，获取已展开的行数据
   */
  getRowExpandRecords(): any[]
  /**
   * 用于 tree-config，用于树表格，获取已展开的节点
   * 注意，即使父节点被收起，只要该节点还处于展开状态都能获取到
   */
  getTreeExpandRecords(): any[]
  /**
   * 用于 tree-config.lazy，用于懒加载树表格，判断树节点是否懒加载完成
   */
  isTreeExpandLoaded(row: any): boolean
  /**
   * 用于 tree-config.lazy，手动清空懒加载树节点的状态，数据会恢复成未展开的状态，当再次展开时会重新加载
   */
  clearTreeExpandLoaded(row: any): Promise<any>
  /**
   * 重新懒加载树节点，并展开该节点
   * @param rows 指定行
   */
  reloadTreeExpand(row: any): Promise<any>
  /**
   * @deprecated 已废弃，请使用 reloadTreeExpand
   */
  reloadTreeChilds(row: any): Promise<any>
  /**
   * 用于 tree-config，切换展开树形节点的状态
   * @param row 指定行
   */
  toggleTreeExpand(row: any): Promise<any>
  /**
   * 用于 tree-config，设置所有树节点的展开与否
   * 如果是关闭所有树节点，可以使用 clearTreeExpand 快速清除
   * @param checked 是否选中
   */
  setAllTreeExpand(checked: boolean): Promise<any>
  /**
   * 用于 tree-config，设置展开树形节点，二个参数设置这一行展开与否
   * @param rows 指定行
   * @param checked 是否选中
   */
  setTreeExpand(rows: any | any[], checked: boolean): Promise<any>
  /**
   * 用于 tree-config，判断行是否为树形节点展开状态
   * @param row 指定行
   */
  isTreeExpandByRow(row: any): boolean
  /**
   * 用于 tree-config，手动清空树形节点的展开状态，数据会恢复成未展开的状态
   */
  clearTreeExpand(): Promise<any>
  /**
   * 用于 tree-config.reserve，手动清空用户保留树节点的展开状态
   */
  clearTreeExpandReserve(): Promise<any>
  /**
   * 获取表格的滚动状态
   */
  getScroll(): {
    virtualX: boolean
    virtualY: boolean
    scrollTop: number
    scrollLeft: number
  }
  /**
   * 如果有滚动条，则滚动到对应的位置
   * @param scrollLeft 左边距离
   * @param scrollTop 顶部距离
   */
  scrollTo(scrollLeft: number | null, scrollTop?: number | null): Promise<void>
  /**
   * 如果有滚动条，则滚动到对应的行
   * @param row 指定行
   * @param columnOrField 列对象或字段名
   */
  scrollToRow(row: any, fieldOrColumn?: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo): Promise<any>
  /**
   * 如果有滚动条，则滚动到对应的列
   * @param columnOrField 列对象或字段名
   */
  scrollToColumn(fieldOrColumn: VxeColumnPropTypes.Field | VxeTableDefines.ColumnInfo): Promise<any>
  /**
   * 手动清除滚动相关信息，还原到初始状态
   */
  clearScroll(): Promise<any>
  /**
   * 手动更新表尾
   */
  updateFooter(): Promise<any>
  /**
   * 更新单元格状态
   * @param params 插槽对象
   */
  updateStatus(
    params: {
      row: any
      column: VxeTableDefines.ColumnInfo
    },
    cellValue?: any
  ): Promise<any>
  /**
   * 取消单元格的临时合并状态，如果为数组，则取消多个合并
   */
  removeMergeCells(merges: VxeTableDefines.MergeOptions | VxeTableDefines.MergeOptions[]): Promise<VxeTableDefines.MergeInfo[]>
  /**
   * 取消表尾的临时合并状态，如果为数组，则取消多个合并
   */
  removeMergeFooterItems(merges: VxeTableDefines.MergeOptions | VxeTableDefines.MergeOptions[]): Promise<VxeTableDefines.MergeInfo[]>
  /**
   * 临时合并单元格，如果为数组则合并多个
   */
  setMergeCells(merges: VxeTableDefines.MergeOptions | VxeTableDefines.MergeOptions[]): Promise<any>
  /**
   * 临时合并表尾，如果为数组则合并多个
   */
  setMergeFooterItems(merges: VxeTableDefines.MergeOptions | VxeTableDefines.MergeOptions[]): Promise<any>
  /**
   * 用于 mouse-config.area，更新已选区域的单元格样式
   */
  updateCellAreas(): Promise<void>
  /**
   * 连接工具栏
   * @param toolbar 工具栏组件实例
   */
  connect(toolbar: VxeToolbarConstructor | VxeToolbarInstance): Promise<any>
  /**
   * 使表格获取焦点
   */
  focus(): Promise<any>
  /**
   * 使表格失去焦点
   */
  blur(): Promise<any>
}

export interface VxeTableMethods extends TableMethods { }

export interface TablePrivateMethods {
  getSetupOptions(): VXETableSetupOptions
  updateAfterDataIndex(): void
  callSlot<T>(slotFunc: ((params: T) => SlotVNodeType | SlotVNodeType[]) | string | null, params: T): SlotVNodeType[]
  getParentElem(): Element | null
  getParentHeight(): number
  getExcludeHeight(): number
  defineField(records: any[]): any
  handleTableData(force?: boolean): Promise<any>
  cacheRowMap(isSource?: boolean): void
  saveCustomResizable(isReset?: boolean): void
  saveCustomVisible(): void
  analyColumnWidth(): void
  checkSelectionStatus(): void
  handleSelectRow(params: any, value: any, isForce?: boolean): void
  handleCustom(): Promise<any>
  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
  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
  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
    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
  triggerScrollXEvent(evnt: Event): void
  triggerScrollYEvent(evnt: Event): void
  scrollToTreeRow(row: any): Promise<any>
  updateScrollYStatus(fullData?: any[]): boolean
  updateScrollXSpace(): void
  updateScrollYSpace(): void
  updateScrollXData(): void
  updateScrollYData(): void
  checkScrolling(): void
  updateZindex(): void
  handleCheckedCheckboxRow(rows: any, value: boolean, isForce?: boolean): Promise<any>
  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
  findRowIndexOf(list: any[], row: any): number
  eqRow(row1: any, row2: any): boolean
}

export interface VxeTablePrivateMethods extends TablePrivateMethods { }

export interface TableReactData {
  // 低性能的静态列
  staticColumns: any[]
  // 渲染的列分组
  tableGroupColumn: any[]
  // 可视区渲染的列
  tableColumn: any[]
  // 渲染中的数据
  tableData: any[]
  // 是否启用了横向 X 可视渲染方式加载
  scrollXLoad: boolean
  // 是否启用了纵向 Y 可视渲染方式加载
  scrollYLoad: boolean
  // 是否存在纵向滚动条
  overflowY: boolean
  // 是否存在横向滚动条
  overflowX: boolean
  // 纵向滚动条的宽度
  scrollbarWidth: number
  // 横向滚动条的高度
  scrollbarHeight: number
  // 行高
  rowHeight: number
  // 表格父容器的高度
  parentHeight: number
  // 是否使用分组表头
  isGroup: boolean
  isAllOverflow: boolean
  // 复选框属性，是否全选
  isAllSelected: boolean
  // 复选框属性，有选中且非全选状态
  isIndeterminate: boolean
  // 复选框属性，已选中的行
  selection: any[]
  // 当前行
  currentRow: any
  // 单选框属性，选中列
  currentColumn: any
  // 单选框属性，选中行
  selectRow: any
  // 表尾合计数据
  footerTableData: any[][]
  // 展开列信息
  expandColumn: any
  hasFixedColumn: boolean
  // 树节点列信息
  treeNodeColumn: any
  // 已展开的行
  rowExpandeds: any[]
  // 懒加载中的展开行的列表
  expandLazyLoadeds: any[]
  // 已展开树节点
  treeExpandeds: any[]
  // 懒加载中的树节点的列表
  treeLazyLoadeds: any[]
  // 树节点不确定状态的列表
  treeIndeterminates: any[]
  // 合并单元格的对象集
  mergeList: VxeTableDefines.MergeItem[]
  // 合并表尾数据的对象集
  mergeFooterList: VxeTableDefines.MergeItem[]
  // 初始化标识
  initStore: {
    filter: boolean
    import: boolean
    export: boolean
  },
  // 当前选中的筛选列
  filterStore: {
    isAllSelected: boolean
    isIndeterminate: boolean
    style: any
    options: any[]
    column: any
    multiple: boolean
    visible: boolean
    maxHeight: number | null
    [key: string]: any
  },
  // 存放列相关的信息
  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[]
  },
  // 存放快捷菜单的信息
  ctxMenuStore: {
    selected: any
    visible: boolean
    showChild: boolean
    selectChild: any
    list: any[][]
    style: any
    [key: string]: any
  },
  // 存放可编辑相关信息
  editStore: {
    indexs: {
      columns: any[]
    },
    titles: {
      columns: any[]
    },
    // 选中源
    selected: {
      row: any
      column: any
      [key: string]: any
    },
    // 已复制源
    copyed: {
      cut: boolean
      rows: any[]
      columns: any[]
      [key: string]: any
    },
    // 激活
    actived: {
      row: any
      column: any
      [key: string]: any
    },
    insertList: any[]
    insertMaps: {
      [key: string]: any
    }
    removeList: any[]
    removeMaps: {
      [key: string]: any
    }
  },
  // 存放 tooltip 相关信息
  tooltipStore: {
    row: any
    column: any
    content: any
    visible: boolean,
    currOpts: any
  }
  // 存放数据校验相关信息
  validStore: {
    visible: boolean
    row: any
    column: any
    content: any
    rule: any
    isArrow: boolean
  },
  // 导入相关信息
  importStore: {
    inited: boolean
    file: any
    type: any
    modeList: any[]
    typeList: any[]
    filename: any
    visible: boolean
  },
  importParams: {
    mode: any
    types: any
    message: boolean
  },
  // 导出相关信息
  exportStore: {
    inited: boolean
    name: any
    modeList: any[]
    typeList: any[]
    columns: any[]
    isPrint: boolean
    hasFooter: boolean
    hasMerge: boolean
    hasTree: boolean
    hasColgroup: boolean
    visible: boolean
  },
  exportParams: {
    filename: any
    sheetName: any
    mode: any
    type: any
    isColgroup: boolean
    isMerge: boolean
    isAllExpand: boolean
    useStyle: boolean
    original: boolean
    message: boolean
    isHeader: boolean
    isFooter: boolean
  }
}

export interface TableInternalData {
  tZindex: number
  elemStore: {
    [key: string]: Ref<HTMLElement> | null
  }
  // 存放横向 X 虚拟滚动相关的信息
  scrollXStore: {
    offsetSize: number
    visibleSize: number
    startIndex: number
    endIndex: number
  }
  // 存放纵向 Y 虚拟滚动相关信息
  scrollYStore: {
    adaptive?: boolean
    rowHeight: number
    offsetSize: number
    visibleSize: number
    startIndex: number
    endIndex: number
  }
  // 表格宽度
  tableWidth: number
  // 表格高度
  tableHeight: number
  // 表头高度
  headerHeight: number
  // 表尾高度
  footerHeight: number
  customHeight: number
  customMaxHeight: number
  // 当前 hover 行
  hoverRow: any
  // 最后滚动位置
  lastScrollLeft: number
  lastScrollTop: number
  lastScrollTime: number
  // 单选框属性，已选中保留的行
  radioReserveRow: any
  // 复选框属性，已选中保留的行
  checkboxReserveRowMap: any
  // 行数据，已展开保留的行
  rowExpandedReserveRowMap: any
  // 树结构数据，已展开保留的行
  treeExpandedReserveRowMap: any
  // 列表完整数据、条件处理后
  tableFullData: any[]
  afterFullData: any[]
  tableSynchData: any[]
  tableSourceData: any[]
  // 树的全量数据、条件处理后
  tableFullTreeData: any[]
  afterTreeFullData: any[]
  // 收集的列配置（带分组）
  collectColumn: VxeTableDefines.ColumnInfo[],
  // 完整所有列（不带分组）
  tableFullColumn: VxeTableDefines.ColumnInfo[]
  // 渲染所有列
  visibleColumn: VxeTableDefines.ColumnInfo[]
  // 缓存数据集
  fullAllDataRowIdData: {
    [key: string]: {
      row: any
      rowid: string
      seq: string | number
      index: number
      $index: number
      _index: number
      items: any[]
      parent: any
      level: number
      treeLoaded?: boolean
      expandLoaded?: boolean
      formatData?: {
        [key: string]: {
          value: any
          label: any
        }
      }
    }
  }
  fullDataRowIdData: {
    [key: string]: {
      row: any
      rowid: string
      seq: string | number
      index: number
      $index: number
      _index: number
      items: any[]
      parent: any
      level: number
    }
  }
  fullColumnIdData: {
    [key: string]: {
      column: VxeTableDefines.ColumnInfo
      colid: string
      index: number
      $index: number
      _index: number
      items: VxeTableDefines.ColumnInfo[]
      parent: VxeTableDefines.ColumnInfo
    }
  }
  fullColumnFieldData: {
    [key: string]: {
      column: VxeTableDefines.ColumnInfo
      colid: string
      index: number
      items: VxeTableDefines.ColumnInfo[]
      parent: VxeTableDefines.ColumnInfo
    }
  }

  // 特殊标识
  inited: boolean
  tooltipTimeout: any
  initStatus: boolean
  isActivated: boolean

  // 内部属性
  _lastResizeTime?: any
  _isResize?: boolean
  _keyCtx?: any
  _lastCallTime?: any
  _importResolve?: ((...args: any[]) => any) | null
  _importReject?: ((...args: any[]) => any) | null
  _currFilterParams?: any
  _currMenuParams?: any
}

export namespace VxeTablePropTypes {
  export type Size = SizeType
  export type ID = string
  export type Data<T = any> = T[]
  export type Height = number | string
  export type MaxHeight = number | string
  export type Resizable = boolean
  export type Stripe = boolean
  export type Round = boolean
  export type Border = boolean | 'default' | 'full' | 'outer' | 'inner' | 'none' | ''
  export type Loading = boolean
  export type Align = 'left' | 'center' | 'right' | '' | null
  export type HeaderAlign = Align
  export type FooterAlign = Align
  export type ShowHeader = boolean
  export type HighlightCurrentRow = boolean
  export type HighlightHoverRow = boolean
  export type HighlightCurrentColumn = boolean
  export type HighlightHoverColumn = boolean
  export type HighlightCell = boolean
  export type ShowFooter = boolean

  export type FooterMethod = (params: {
    $table: VxeTableConstructor & VxeTablePrivateMethods
    $grid: VxeGridConstructor | null | undefined
    columns: VxeTableDefines.ColumnInfo[]
    data: any[]
  }) => Array<string | number | null>[]

  export type RowClassName = string | ((params: {
    row: any
    rowIndex: number
    $rowIndex: number
    _rowIndex: number
  }) => void | null | string | { [key: string]: boolean })

  export type CellClassName = string | ((params: {
    row: any
    rowIndex: number
    $rowIndex: number
    _rowIndex: number
    column: VxeTableDefines.ColumnInfo
    columnIndex: number
    $columnIndex: number
    _columnIndex: number
  }) => void | null | string | { [key: string]: boolean })

  export type HeaderRowClassName = string | ((params: {
    $table: VxeTableConstructor & VxeTablePrivateMethods
    $rowIndex: number
    fixed: VxeColumnPropTypes.Fixed
    type: string
  }) => void | null | string | { [key: string]: boolean })

  export type HeaderCellClassName = string | ((params: {
    $table: VxeTableConstructor & VxeTablePrivateMethods
    $rowIndex: number
    column: VxeTableDefines.ColumnInfo
    fixed: VxeColumnPropTypes.Fixed
    type: string
  }) => void | null | string | { [key: string]: boolean })

  export type FooterRowClassName = string | ((params: {
    $table: VxeTableConstructor & VxeTablePrivateMethods
    $rowIndex: number
    _rowIndex: number
    fixed: VxeColumnPropTypes.Fixed
    type: string
  }) => void | null | string | { [key: string]: boolean })

  export type FooterCellClassName = string | ((params: {
    $table: VxeTableConstructor & VxeTablePrivateMethods
    $rowIndex: number
    _rowIndex: number
    column: VxeTableDefines.ColumnInfo
    columnIndex: number
    $columnIndex: number
    _columnIndex: number
  }) => void | null | string | { [key: string]: boolean })

  export type CellStyle = VNodeStyle | ((params: {
    row: any
    rowIndex: number
    $rowIndex: number
    _rowIndex: number
    column: VxeTableDefines.ColumnInfo
    columnIndex: number
    $columnIndex: number
    _columnIndex: number
  }) => void | null | VNodeStyle)

  export type HeaderCellStyle = VNodeStyle | ((params: {
    $table: VxeTableConstructor & VxeTablePrivateMethods
    $rowIndex: number
    column: VxeTableDefines.ColumnInfo
    columnIndex: number
    _columnIndex: number
  }) => void | null | VNodeStyle)

  export type FooterCellStyle = VNodeStyle | ((params: {
    $rowIndex: number
    column: VxeTableDefines.ColumnInfo
    columnIndex: number
    $columnIndex: number
    _columnIndex: number
  }) => void | null | VNodeStyle)

  export type RowStyle = VNodeStyle | ((params: {
    row: any
    rowIndex: number
    $rowIndex: number
    _rowIndex: number
  }) => void | null | VNodeStyle)

  export type HeaderRowStyle = VNodeStyle | ((params: {
    $table: VxeTableConstructor & VxeTablePrivateMethods
    $rowIndex: number
    fixed: VxeColumnPropTypes.Fixed
    type: string
  }) => void | null | VNodeStyle)

  export type FooterRowStyle = VNodeStyle | ((params: {
    $table: VxeTableConstructor & VxeTablePrivateMethods
    $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 SpanMethod = (params: {
    column: VxeTableDefines.ColumnInfo
    columnIndex: number
    $columnIndex: number
    row: any
    rowIndex: number
    $rowIndex: number
    _rowIndex: number
    isHidden: boolean
    fixed: VxeColumnPropTypes.Fixed
    type: string
    visibleData: any[]
  }) => void | { rowspan: number, colspan: number }

  export type FooterSpanMethod = (params: {
    column: VxeTableDefines.ColumnInfo
    columnIndex: number
    _columnIndex: number
    $columnIndex: number
    $rowIndex: number
    _rowIndex: number
    items: any[]
    data: any[][]
  }) => void | { rowspan: number, colspan: number }

  export type ShowOverflow = boolean | 'ellipsis' | 'title' | 'tooltip' | '' | null
  export type ShowHeaderOverflow = ShowOverflow
  export type ShowFooterOverflow = ShowOverflow
  export type ColumnKey = boolean
  export type RowKey = boolean
  export type RowId = string
  export type KeepSource = boolean
  export type AutoResize = boolean
  export type SyncResize = boolean | string | number

  /**
   * 响应式布局配置项
   */
  export interface ResizeConfig {
    refreshDelay?: number
  }
  export interface ResizeOpts extends ResizeConfig { }

  /**
   * 列配置信息
   */
  export interface ColumnConfig {
    useKey?: boolean
    isCurrent?: boolean
    isHover?: boolean
    resizable?: VxeColumnPropTypes.Resizable
    width?: VxeColumnPropTypes.Width
    minWidth?: VxeColumnPropTypes.MinWidth
    maxWidth?: VxeColumnPropTypes.MaxWidth
  }
  export interface ColumnOpts extends ColumnConfig { }

  /**
   * 行配置信息
   */
  export interface RowConfig {
    useKey?: boolean
    keyField?: string
    isCurrent?: boolean
    isHover?: boolean
    height?: number
  }
  export interface RowOpts extends RowConfig { }

  /**
   * 自定义列配置项
   */
  export interface CustomConfig {
    storage?: boolean | {
      visible?: boolean
      resizable?: boolean
    }
    checkMethod?(params: { column: VxeTableDefines.ColumnInfo }): boolean
  }
  export interface CustomOpts extends CustomConfig { }

  /**
   * 列调整配置项
   */
  export interface ResizableConfig {
    minWidth?: number | string | ((params: {
      $table: VxeTableConstructor & VxeTablePrivateMethods
      column: VxeTableDefines.ColumnInfo
      columnIndex: number
      $columnIndex: number
      $rowIndex: number
      cell: HTMLElement
    }) => number | string)
    maxWidth?: number | string | ((params: {
      $table: VxeTableConstructor & VxeTablePrivateMethods
      column: VxeTableDefines.ColumnInfo
      columnIndex: number
      $columnIndex: number
      $rowIndex: number
      cell: HTMLElement
    }) => number | string)
  }
  export interface ResizableOpts extends ResizableConfig { }

  /**
   * 序号配置项
   */
  export interface SeqConfig {
    startIndex?: number
    seqMethod?(params: {
      column: VxeTableDefines.ColumnInfo
      columnIndex: number
      $columnIndex: number
      row: any
      rowIndex: number
      $rowIndex: number
    }): number | string
  }
  export interface SeqOpts extends SeqConfig { }

  interface SortConfigDefaultSort {
    field: string
    order: SortOrder
  }

  /**
   * 排序配置项
   */
  export interface SortConfig {
    defaultSort?: SortConfigDefaultSort | SortConfigDefaultSort[]
    orders?: SortOrder[]
    sortMethod?(params: {
      $table: VxeTableConstructor & VxeTablePrivateMethods
      data: any[]
      sortList: VxeTableDefines.SortCheckedParams[]
    }): any[]
    remote?: boolean
    multiple?: boolean
    chronological?: boolean
    trigger?: 'default' | 'cell'
    showIcon?: boolean
    iconAsc?: string
    iconDesc?: string
  }
  export type SortOrder = 'asc' | 'desc' | '' | null
  export interface SortOpts extends SortConfig {
    orders: SortOrder[]
  }

  /**
   * 筛选配置项
   */
  export interface FilterConfig {
    filterMethod?: (params: {
      options: VxeTableDefines.FilterOption[]
      values: any[]
      cellValue: any
      row: any
      column: VxeTableDefines.ColumnInfo
    }) => any
    remote?: boolean
    showIcon?: boolean
    iconNone?: string
    iconMatch?: string
  }
  export interface FilterOpts extends FilterConfig { }

  /**
   * 单选框配置
   */
  export interface RadioConfig {
    reserve?: boolean
    labelField?: string
    checkRowKey?: string | number
    checkMethod?(params: {
      row: any
    }): boolean
    visibleMethod?(params: {
      row: any
    }): boolean
    trigger?: 'default' | 'cell' | 'row' | '' | null
    highlight?: boolean
    strict?: boolean
  }
  export interface RadioOpts extends RadioConfig { }

  /**
   * 复选框配置项
   */
  export interface CheckboxConfig {
    reserve?: boolean
    labelField?: string
    checkField?: string
    halfField?: string
    showHeader?: boolean
    checkAll?: boolean
    checkRowKeys?: string[] | number[]
    checkStrictly?: boolean
    strict?: boolean
    checkMethod?(params: {
      row: any
    }): boolean
    visibleMethod?(params: {
      row: any
    }): boolean
    trigger?: 'default' | 'cell' | 'row' | '' | null
    highlight?: boolean
    range?: boolean
  }
  export interface CheckboxOpts extends CheckboxConfig { }

  /**
   * 提示信息配置项
   */
  export interface TooltipConfig {
    showAll?: boolean
    theme?: 'dark' | 'light' | '' | null
    enterable?: boolean
    enterDelay?: number
    leaveDelay?: number
    contentMethod?(params: {
      items: any[]
      row: any
      rowIndex: number
      $rowIndex: number
      _rowIndex: number
      column: VxeTableDefines.ColumnInfo
      columnIndex: number
      $columnIndex: number
      _columnIndex: number
      type: 'header' | 'body' | 'footer' | '' | null
      cell: HTMLElement
      $event: any
    }): string | null | void
  }
  export interface TooltipOpts extends TooltipConfig { }

  /**
   * 展开行配置项
   */
  export interface ExpandConfig {
    labelField?: string
    expandAll?: boolean
    expandRowKeys?: string[] | number[]
    accordion?: boolean
    trigger?: 'default' | 'cell' | 'row' | '' | null
    lazy?: boolean
    reserve?: boolean
    height?: number
    loadMethod?(params: {
      $table: VxeTableConstructor & VxeTablePrivateMethods
      row: any
      rowIndex: number
      $rowIndex: number
    }): Promise<void>
    toggleMethod?(params: {
      $table: VxeTableConstructor & VxeTablePrivateMethods
      expanded: boolean
      row: any
      rowIndex: number
      $rowIndex: number
      column: VxeTableDefines.ColumnInfo
      columnIndex: number
      $columnIndex: number
    }): boolean
    visibleMethod?(params: VxeTableDefines.CellRenderBodyParams): boolean
    showIcon?: boolean
    iconOpen?: string
    iconClose?: string
    iconLoaded?: string
  }
  export interface ExpandOpts extends ExpandConfig { }

  /**
   * 树形结构配置项
   */
  export interface TreeConfig {
    transform?: boolean
    rowField?: string
    parentField?: string
    children?: string
    mapChildren?: string
    indent?: number
    line?: boolean
    expandAll?: boolean
    expandRowKeys?: string[] | number[]
    accordion?: boolean
    trigger?: 'default' | 'cell' | 'row' | '' | null
    lazy?: boolean
    hasChild?: string
    reserve?: boolean
    loadMethod?(params: {
      $table: VxeTableConstructor & VxeTablePrivateMethods
      row: any
    }): Promise<any[]>
    toggleMethod?(params: {
      $table: VxeTableConstructor & VxeTablePrivateMethods
      expanded: boolean
      row: any
      column: VxeTableDefines.ColumnInfo
      columnIndex: number
      $columnIndex: number
    }): boolean
    showIcon?: boolean
    iconOpen?: string
    iconClose?: string
    iconLoaded?: string
  }
  export interface TreeOpts extends TreeConfig {
    rowField: string
    parentField: string
    children: string
    indent: number
    hasChild: string
    mapChildren: string
    iconOpen: string
    iconClose: string
    iconLoaded: string
  }

  /**
   * 快捷菜单配置项
   */
  export interface MenuConfig {
    header?: VxeTableDefines.MenuOptions
    body?: VxeTableDefines.MenuOptions
    footer?: VxeTableDefines.MenuOptions
    trigger?: 'default' | 'cell' | '' | null
    className?: string
    visibleMethod?(params: {
      type: string
      options: VxeTableDefines.MenuFirstOption[][]
      columns: VxeTableDefines.ColumnInfo[]
      row?: any
      rowIndex?: number
      column?: VxeTableDefines.ColumnInfo
      columnIndex?: number
    }): boolean
  }

  /**
   * 鼠标配置项
   */
  export interface MouseConfig {
    selected?: boolean
    /**
     * 如果功能被支持，则开启单元格区域选取功能，非连续的区域，按住 Ctrl 键，用鼠标逐一选取
     */
    area?: boolean
    /**
     * 只对 area 启用后有效，是否开启区域扩展选取功能，开启后可以通过鼠标左键按住区域内右下角扩展按钮，将区域横向或纵向扩大（支持扩大区域并复制值）
     */
    extension?: boolean
  }
  export interface MouseOpts extends MouseConfig { }

  /**
   * 区域配置项
   */
  export interface AreaConfig {
    /**
     * 只对 mouse-config.area 启用后有效，点击列头是否选取当前列的所有单元格
     */
    selectCellByHeader?: boolean
    /**
     * 只对 mouse-config.extension 启用后有效，将被选取区域的值复制到扩展区域中
     */
    extendByCopy?: boolean
    /**
     * 只对 mouse-config.extension 启用后有效，扩展区域时将自动识别数字规则进行计算
     */
    extendByCalc?: boolean
    /**
     * 只对 extendByCalc 启用后有效，重写单元格扩展区域计算值的方法
     * @param params
     */
    extendCalcMethod?(params: VxeTableProDefines.ExtendCellAreaCalcBaseParams): any[][]
    /**
     * 只对 extendByCopy | extendByCalc 启用后有效，重写单元格扩展区域赋值的方法
     * @param params
     */
    extendSetMethod?(params: {
      cellValue: any
      row: any
      column: VxeTableDefines.ColumnInfo
    } & VxeTableProDefines.ExtendCellAreaCalcBaseParams): void
    /**
     * 只对 extendByCopy | extendByCalc 启用后有效，自定义单元格扩展区域赋值之前的方法，可以通过返回 false 阻止扩展行为
     * @param params
     */
    beforeExtendSetMethod?(params: VxeTableProDefines.ExtendCellAreaCalcBaseParams): boolean
    /**
     * 只对 extendByCopy | extendByCalc 启用后有效，自定义单元格扩展区域赋值之后的方法
     * @param params
     */
    afterExtendSetMethod?(params: {
      extendValues: any[][]
    } & VxeTableProDefines.ExtendCellAreaCalcBaseParams): boolean
  }
  export interface AreaOpts extends AreaConfig { }

  /**
   * 按键配置项
   */
  export interface KeyboardConfig {
    /**
     * 是否开启非编辑状态下，上下左右移动功能
     */
    isArrow?: boolean
    /**
     * 是否开启Esc键退出编辑功能
     */
    isEsc?: boolean
    /**
     * 是否开启删除键功能
     */
    isDel?: boolean
    /**
     * 是否开启回车移动上下行移动
     */
    isEnter?: boolean
    /**
     * 如果功能被支持，用于 mouse-config.area，开启同时按住方向键以活动区域为起始，向指定方向延伸单元格区域
     */
    isShift?: boolean
    /**
     * 是否开启TAB键左右移动功能
     */
    isTab?: boolean
    /**
     * 是否开启单元格选择编辑
     */
    isEdit?: boolean
    /**
     * 用于 mouse-config.area，开启合并和取消合并功能
     */
    isMerge?: boolean
    /**
     * 用于 mouse-config.area，开启复制/剪贴/粘贴功能
     */
    isClip?: boolean
    /**
     * 如果功能被支持，用于 mouse-config.area，开启查找和替换功能
     */
    isFNR?: boolean
    /**
     * 用于 mouse-config.area & column.type=checkbox|radio，开启空格键切换复选框或单选框状态功能
     */
    isChecked?: boolean
    /**
     * 用于 mouse-config.area，是否将回车键行为改成 Tab 键行为
     */
    enterToTab?: boolean
    /**
     * 只对 isDel=true 有效，用于删除键清空单元格内容方法
     */
    delMethod?(params: {
      row: any
      rowIndex: number
      column: VxeTableDefines.ColumnInfo
      columnIndex: number
      $table: VxeTableConstructor & VxeTablePrivateMethods
    }): void
    /**
     * 只对 isDel=true 有效，用于重写回退键清空单元格内容并激活为编辑状态方法
     */
    backMethod?(params: {
      row: any
      rowIndex: number
      column: VxeTableDefines.ColumnInfo
      columnIndex: number
      $table: VxeTableConstructor & VxeTablePrivateMethods
    }): void
    /**
     * 只对 isEdit=true 有效，用于重写编辑单元格方法
     */
    editMethod?(params: {
      row: any
      rowIndex: number
      column: VxeTableDefines.ColumnInfo
      columnIndex: number
      $table: VxeTableConstructor & VxeTablePrivateMethods
      $grid: VxeGridConstructor | null | undefined
    }): boolean
  }
  export interface KeyboardOpts extends KeyboardConfig { }

  /**
   * 复制/粘贴配置项
   */
  export interface ClipConfig {
    /**
     * 是否启用复制功能
     */
    isCopy?: boolean
    /**
     * 是否启用剪贴功能
     */
    isCut?: boolean
    /**
     * 是否启用粘贴功能
     */
    isPaste?: boolean
    /**
     * 是否填充粘贴，如果启用了，当被选取的粘贴单元格与粘贴单元格的行与列数量不匹配时，会将内容强制粘贴所选的单元格
     */
    isFillPaste?: boolean
    /**
     * 是否启用行自增，当粘贴的行数超出表格时自动插入新行
     */
    isRowIncrement?: boolean
    /**
     * 是否启用列自增，当粘贴的列数超出表格时自动插入新列（需要注意自增的列自字段是否定义，否则将无法响应）
     */
    isColumnIncrement?: boolean
    /**
     * 重写单元格复制取值的方法，将单元格复制到剪贴板
     */
    copyMethod?(params: {
      isCut: boolean
      row: any
      column: VxeTableDefines.ColumnInfo
      cellValue: any
      $table: VxeTableConstructor & VxeTablePrivateMethods
      $grid: VxeGridConstructor | null | undefined
    }): string
    /**
     * 自定义单元格复制取值之前的方法，可以通过返回 false 阻止复制行为
     */
    beforeCopyMethod?(params: {
      isCut: boolean
      activeArea: VxeTableProDefines.MouseActiveCellArea
      targetAreas: VxeTableProDefines.CellAreaParams[]
      $table: VxeTableConstructor & VxeTablePrivateMethods
      $grid: VxeGridConstructor | null | undefined
    }): boolean
    /**
     * 自定义单元格复制到剪贴板之后的方法
     */
    afterCopyMethod?(params: {
      isCut: boolean
      targetAreas: VxeTableProDefines.CellAreaParams[]
      $table: VxeTableConstructor & VxeTablePrivateMethods
      $grid: VxeGridConstructor | null | undefined
    }): boolean
    /**
     * 重写单元格剪贴值清除的方法，将剪贴单元格的值清除
     */
    cutMethod?: (params: {
      row: any,
      column: VxeTableDefines.ColumnInfo
      cellValue: any
      $table: VxeTableConstructor & VxeTablePrivateMethods
      $grid: VxeGridConstructor | null | undefined
    }) => void
    /**
     * 自定义单元格剪贴值清除之前的方法，可以通过返回 false 阻止清除行为
     */
    beforeCutMethod?: (params: {
      activeArea: VxeTableProDefines.MouseActiveCellArea
      cutAreas: VxeTableProDefines.CellAreaParams[]
      currentAreas: VxeTableProDefines.CellAreaParams[]
      $table: VxeTableConstructor & VxeTablePrivateMethods
      $grid: VxeGridConstructor | null | undefined
    }) => boolean
    /**
     * 自定义单元格剪贴值清除之后的方法
     */
    afterCutMethod?: (params: {
      cutAreas: VxeTableProDefines.CellAreaParams[]
      currentAreas: VxeTableProDefines.CellAreaParams[]
      $table: VxeTableConstructor & VxeTablePrivateMethods
      $grid: VxeGridConstructor | null | undefined
    }) => void
    /**
     * 重写单元格粘贴赋值的方法，从剪贴板赋值到单元格
     */
    pasteMethod?(params: {
      isCut: boolean
      row: any,
      column: VxeTableDefines.ColumnInfo
      cellValue: any
      $table: VxeTableConstructor & VxeTablePrivateMethods
      $grid: VxeGridConstructor | null | undefined
    }): void
    /**
     * 自定义单元格粘贴赋值之前的方法，可以通过返回 false 阻止复制行为
     */
    beforePasteMethod?(params: {
      isCut: boolean
      activeArea: VxeTableProDefines.MouseActiveCellArea
      cutAreas: VxeTableProDefines.CellAreaParams[]
      currentAreas: VxeTableProDefines.CellAreaParams[]
      targetAreas: VxeTableProDefines.CellAreaParams[]
      cellValues: string[][]
      pasteCells: string[][]
      $table: VxeTableConstructor & VxeTablePrivateMethods
      $grid: VxeGridConstructor | null | undefined
    }): boolean
    /**
     * 自定义单元格粘贴赋值之后的方法
     */
    afterPasteMethod?(params: {
      isCut: boolean
      currentAreas: VxeTableProDefines.CellAreaParams[]
      cutAreas: VxeTableProDefines.CellAreaParams[]
      targetAreas: VxeTableProDefines.CellAreaParams[]
      cellValues: any[][]
      pasteCells: string[][]
      insertRows: any[]
      insertColumns: VxeTableDefines.ColumnInfo[]
      $table: VxeTableConstructor & VxeTablePrivateMethods
      $grid: VxeGridConstructor | null | undefined
    }): boolean
    /**
     * 只对 isRowIncrement 有效，自定义创建自增行数据的方法
     */
    createRowsMethod?(params: {
      currentAreas: VxeTableProDefines.CellAreaParams[]
      targetAreas: VxeTableProDefines.CellAreaParams[]
      cellValues: any[][]
      pasteCells: string[][]
      insertRows: any[]
      $table: VxeTableConstructor & VxeTablePrivateMethods
      $grid: VxeGridConstructor | null | undefined
    }): any[]
    /**
     * 只对 isColumnIncrement 有效，自定义创建自增列配置的方法
     */
    createColumnsMethod?(params: {
      currentAreas: VxeTableProDefines.CellAreaParams[]
      targetAreas: VxeTableProDefines.CellAreaParams[]
      cellValues: any[][]
      pasteCells: string[][]
      insertColumns: VxeTableDefines.ColumnOptions[]
      $table: VxeTableConstructor & VxeTablePrivateMethods
      $grid: VxeGridConstructor | null | undefined
    }): VxeTableDefines.ColumnOptions[]
  }
  export interface ClipOpts extends ClipConfig { }

  /**
   * 查找/替换配置项
   */
  export interface FNRConfig {
    isFind?: boolean
    findMethod?(params: {
      cellValue: any
      isWhole: boolean
      isRE: boolean
      isSensitive: boolean
      findValue: string | null
      findRE: RegExp | null
    }): boolean
    beforeFindMethod?(params: {
      isAll: boolean
      findValue: string | null
      $table: VxeTableConstructor & VxeTablePrivateMethods
      $grid: VxeGridConstructor | null | undefined
    }): boolean
    afterFindMethod?(params: {
      isAll: boolean
      findValue: string | null
      result: VxeTableProDefines.FindAndReplaceResult[]
      $table: VxeTableConstructor & VxeTablePrivateMethods
      $grid: VxeGridConstructor | null | undefined
    }): void
    isReplace?: boolean
    replaceMethod?: (params: {
      row: any
      column: VxeTableDefines.ColumnInfo
      cellValue: any
    }) => void
    beforeReplaceMethod?: (params: {
      isAll: boolean
      findValue: string | null
      replaceValue: string
      $table: VxeTableConstructor & VxeTablePrivateMethods
      $grid: VxeGridConstructor | null | undefined
    }) => boolean
    afterReplaceMethod?: (params: {
      isAll: boolean
      findValue: string | null
      replaceValue: string
      result: VxeTableProDefines.FindAndReplaceResult[]
      $table: VxeTableConstructor & VxeTablePrivateMethods
      $grid: VxeGridConstructor | null | undefined
    }) => void
  }
  export interface FNROpts extends FNRConfig { }

  /**
   * 编辑配置项
   */
  export interface EditConfig {
    trigger?: 'manual' | 'click' | 'dblclick' | '' | null
    enabled?: boolean
    mode?: string
    icon?: string
    showIcon?: boolean
    showStatus?: boolean
    showUpdateStatus?: boolean
    showInsertStatus?: boolean
    showAsterisk?: boolean
    autoClear?: boolean
    /**
     * 该方法的返回值用来决定该单元格是否允许编辑
     */
    beforeEditMethod?(params: {
      row: any
      rowIndex: number
      column: VxeTableDefines.ColumnInfo
      columnIndex: number
      $table: VxeTableConstructor & VxeTablePrivateMethods
      $grid: VxeGridConstructor | null | undefined
    }): boolean
    /**
     * 请使用 beforeEditMethod
     * @deprecated
     */
    activeMethod?(params: {
      row: any
      rowIndex: number
      column: VxeTableDefines.ColumnInfo
      columnIndex: number
      $table: VxeTableConstructor & VxeTablePrivateMethods
      $grid: VxeGridConstructor | null | undefined
    }): boolean
  }
  export interface EditOpts extends EditConfig { }

  /**
   * 校验配置项
   */
  export interface ValidConfig {
    autoPos?: boolean
    showMessage?: boolean
    message?: string
    maxWidth?: number
  }
  export interface ValidOpts extends ValidConfig { }

  /**
   * 校验规则配置项
   */
  export interface EditRules {
    [field: string]: VxeTableDefines.ValidatorRule[]
  }

  export type ZIndex = number
  export type EmptyText = string

  export interface LoadingConfig {
    icon?: string
    text?: string
  }
  export interface LoadingOpts extends LoadingConfig { }

  export interface EmptyRender extends VxeGlobalRendererHandles.RenderOptions { }
  export interface EmptyOpts extends EmptyRender { }

  export type Fit = boolean
  export type Animat = boolean
  export type DelayHover = number

  export interface ScrollX {
    gt?: number
    oSize?: number
    enabled?: boolean
    scrollToLeftOnChange?: boolean
  }
  export interface SXOpts extends ScrollX {
    gt: number
    oSize: number
  }

  export interface ScrollY {
    mode?: 'default' | 'wheel'
    gt?: number
    oSize?: number
    enabled?: boolean
    scrollToTopOnChange?: boolean
    /**
     * @deprecated 请使用 row-config.height
     */
    rHeight?: number
    adaptive?: boolean
  }
  export interface SYOpts extends ScrollY {
    gt: number
    oSize: number
  }

  export type Params = any
}

export type VxeTableProps<D = any> = {
  size?: VxeTablePropTypes.Size
  id?: VxeTablePropTypes.ID
  data?: VxeTablePropTypes.Data<D>
  height?: VxeTablePropTypes.Height
  maxHeight?: VxeTablePropTypes.MaxHeight
  /**
   * 不建议使用，后续废弃
   * @deprecated
   */
  resizable?: VxeTablePropTypes.Resizable
  stripe?: VxeTablePropTypes.Stripe
  round?: VxeTablePropTypes.Round
  border?: VxeTablePropTypes.Border
  loading?: VxeTablePropTypes.Loading
  align?: VxeTablePropTypes.Align
  headerAlign?: VxeTablePropTypes.HeaderAlign
  footerAlign?: VxeTablePropTypes.FooterAlign
  showHeader?: VxeTablePropTypes.ShowHeader
  highlightCurrentRow?: VxeTablePropTypes.HighlightCurrentRow
  highlightHoverRow?: VxeTablePropTypes.HighlightHoverRow
  highlightCurrentColumn?: VxeTablePropTypes.HighlightCurrentColumn
  highlightHoverColumn?: VxeTablePropTypes.HighlightHoverColumn
  /**
   * 已废弃
   * @deprecated
   */
  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
  showOverflow?: VxeTablePropTypes.ShowOverflow
  showHeaderOverflow?: VxeTablePropTypes.ShowHeaderOverflow
  showFooterOverflow?: VxeTablePropTypes.ShowFooterOverflow
  /**
   * 请使用 column-config.useKey
   * @deprecated
   */
  columnKey?: VxeTablePropTypes.ColumnKey
  /**
   * 请使用 row-config.useKey
   * @deprecated
   */
  rowKey?: VxeTablePropTypes.RowKey
  /**
   * 请使用 row-config.keyField
   * @deprecated
   */
  rowId?: VxeTablePropTypes.RowId
  keepSource?: VxeTablePropTypes.KeepSource
  autoResize?: VxeTablePropTypes.AutoResize
  syncResize?: VxeTablePropTypes.SyncResize
  columnConfig?: VxeTablePropTypes.ColumnConfig
  rowConfig?: VxeTablePropTypes.RowConfig
  customConfig?: VxeTablePropTypes.CustomConfig
  resizeConfig?: VxeTablePropTypes.ResizeConfig
  resizableConfig?: VxeTablePropTypes.ResizableConfig
  seqConfig?: VxeTablePropTypes.SeqConfig
  sortConfig?: VxeTablePropTypes.SortConfig
  filterConfig?: VxeTablePropTypes.FilterConfig
  radioConfig?: VxeTablePropTypes.RadioConfig
  checkboxConfig?: VxeTablePropTypes.CheckboxConfig
  tooltipConfig?: VxeTablePropTypes.TooltipConfig
  exportConfig?: VxeTablePropTypes.ExportConfig
  importConfig?: VxeTablePropTypes.ImportConfig
  printConfig?: VxeTablePropTypes.PrintConfig
  expandConfig?: VxeTablePropTypes.ExpandConfig
  treeConfig?: VxeTablePropTypes.TreeConfig
  menuConfig?: VxeTablePropTypes.MenuConfig
  mouseConfig?: VxeTablePropTypes.MouseConfig
  areaConfig?: VxeTablePropTypes.AreaConfig
  fnrConfig?: VxeTablePropTypes.FNRConfig
  keyboardConfig?: VxeTablePropTypes.KeyboardConfig
  clipConfig?: VxeTablePropTypes.ClipConfig
  editConfig?: VxeTablePropTypes.EditConfig
  validConfig?: VxeTablePropTypes.ValidConfig
  editRules?: VxeTablePropTypes.EditRules
  emptyText?: VxeTablePropTypes.EmptyText
  emptyRender?: VxeTablePropTypes.EmptyRender
  loadingConfig?: VxeTablePropTypes.LoadingConfig
  /**
   * 不建议使用，后续废弃
   * @deprecated
   */
  fit?: VxeTablePropTypes.Fit
  /**
   * 不建议使用，后续废弃
   * @deprecated
   */
  animat?: VxeTablePropTypes.Animat
  /**
   * 不建议使用，后续废弃
   * @deprecated
   */
  delayHover?: VxeTablePropTypes.DelayHover
  scrollX?: VxeTablePropTypes.ScrollX
  scrollY?: VxeTablePropTypes.ScrollY
  params?: VxeTablePropTypes.Params
}

export type VxeTableEmits = [
  'update:data',
  'keydown-start',
  'keydown',
  'keydown-end',
  'paste',
  'copy',
  'cut',
  'current-change',
  'radio-change',
  'checkbox-change',
  'checkbox-all',
  'checkbox-range-start',
  'checkbox-range-change',
  'checkbox-range-end',
  'cell-click',
  'cell-dblclick',
  'cell-menu',
  'cell-mouseenter',
  'cell-mouseleave',
  'cell-selected',
  'header-cell-click',
  'header-cell-dblclick',
  'header-cell-menu',
  'footer-cell-click',
  'footer-cell-dblclick',
  'footer-cell-menu',
  'clear-merge',
  'sort-change',
  'clear-sort',
  'filter-change',
  'filter-visible',
  'clear-filter',
  'resizable-change',
  'toggle-row-expand',
  'toggle-tree-expand',
  'menu-click',
  'edit-closed',
  'edit-actived',
  'edit-disabled',
  'valid-error',
  'scroll',
  'custom',

  ...VxeTableProEmits
]

export namespace VxeTableDefines {
  export interface SortConfs {
    field: string
    order?: VxeTablePropTypes.SortOrder
  }

  export interface MergeOptions {
    row: any | number
    col: VxeTableDefines.ColumnInfo | number
    rowspan: number
    colspan: number
  }

  export interface MergeInfo {
    row: number
    col: number
    rowspan: number
    colspan: number
  }

  export interface MergeItem extends MergeInfo {
    _row: any
    _col: VxeTableDefines.ColumnInfo
    _rowspan: number
    _colspan: number
  }

  export interface ColumnOptions extends VxeColumnProps {
    children?: ColumnOptions[]
    slots?: VxeColumnPropTypes.Slots
  }

  /**
   * 列对象
   */
  export class ColumnInfo {
    /**
     * 该属性已废弃，该属性被 field 替换
     * @deprecated
     */
    property: VxeColumnPropTypes.Field

    /**
     * 公开属性
     */
    type: VxeColumnPropTypes.Type
    field: VxeColumnPropTypes.Field
    title: VxeColumnPropTypes.Title
    width: VxeColumnPropTypes.Width
    minWidth: VxeColumnPropTypes.MinWidth
    maxWidth: VxeColumnPropTypes.MaxWidth
    resizable: VxeColumnPropTypes.Resizable
    fixed: VxeColumnPropTypes.Fixed
    align: VxeColumnPropTypes.Align
    headerAlign: VxeColumnPropTypes.HeaderAlign
    footerAlign: VxeColumnPropTypes.FooterAlign
    showOverflow: VxeColumnPropTypes.ShowOverflow
    showHeaderOverflow: VxeColumnPropTypes.ShowHeaderOverflow
    showFooterOverflow: VxeColumnPropTypes.ShowFooterOverflow
    className: VxeColumnPropTypes.ClassName
    headerClassName: VxeColumnPropTypes.HeaderClassName
    footerClassName: VxeColumnPropTypes.FooterClassName
    formatter: VxeColumnPropTypes.Formatter
    sortable: VxeColumnPropTypes.Sortable
    sortBy: VxeColumnPropTypes.SortBy
    sortType: VxeColumnPropTypes.SortType
    filters: VxeColumnPropTypes.Filter[]
    filterMultiple: VxeColumnPropTypes.FilterMultiple
    filterMethod: VxeColumnPropTypes.FilterMethod
    filterRender: VxeColumnPropTypes.FilterRender
    treeNode: VxeColumnPropTypes.TreeNode
    visible: VxeColumnPropTypes.Visible
    exportMethod: VxeColumnPropTypes.ExportMethod
    footerExportMethod: VxeColumnPropTypes.FooterExportMethod
    /**
     * 已废弃，请使用 titlePrefix
     * @deprecated
     */
    titleHelp: VxeColumnPropTypes.TitleHelp
    titlePrefix: VxeColumnPropTypes.TitlePrefix
    cellType: VxeColumnPropTypes.CellType
    cellRender: VxeColumnPropTypes.CellRender
    editRender: VxeColumnPropTypes.EditRender
    contentRender: VxeColumnPropTypes.ContentRender
    params: VxeColumnPropTypes.Params
    slots: VxeColumnPropTypes.Slots

    /**
     * 以下内部属性
     * 内部属性随时都会调整，不应该被使用
     */
    id: string
    parentId: string
    level: number
    rowSpan: number
    colSpan: number
    halfVisible: boolean
    defaultVisible: any
    checked: boolean
    halfChecked: boolean
    disabled: boolean
    order: VxeTablePropTypes.SortOrder
    sortTime: number
    renderWidth: number
    renderHeight: number
    resizeWidth: number
    model: {
      update: boolean
      value: any
    }

    children: ColumnInfo[]

    renderHeader(params: CellRenderHeaderParams): VNode[]
    renderCell(params: CellRenderCellParams): VNode[]
    renderData(params: CellRenderDataParams): VNode[]
    renderFooter(params: CellRenderFooterParams): VNode[]

    getTitle(): string
    getKey(): string
  }
  export interface CellRenderHeaderParams {
    $table: VxeTableConstructor & VxeTablePrivateMethods
    $grid: VxeGridConstructor | null
    $rowIndex: number
    column: ColumnInfo
    columnIndex: number
    $columnIndex: number
    _columnIndex: number
    fixed: VxeColumnPropTypes.Fixed
    type: string
    isHidden: boolean
    hasFilter: boolean
  }
  export interface CellRenderBodyParams {
    $table: VxeTableConstructor & VxeTablePrivateMethods
    $grid: VxeGridConstructor | null
    seq: string | number
    rowid: string
    row: any
    rowIndex: number
    $rowIndex: number
    _rowIndex: number
    column: ColumnInfo
    columnIndex: number
    $columnIndex: number
    _columnIndex: number
    fixed: VxeColumnPropTypes.Fixed
    type: string
    isHidden: boolean
    level: number
    visibleData: any[]
    data: any[]
    items: any[]
  }

  export interface CellRenderDataParams extends CellRenderBodyParams { }
  export interface CellRenderCellParams extends CellRenderBodyParams { }

  export interface CellRenderFooterParams {
    $table: VxeTableConstructor & VxeTablePrivateMethods
    $grid: VxeGridConstructor | null
    _rowIndex: number
    $rowIndex: number
    column: ColumnInfo
    columnIndex: number
    $columnIndex: number
    _columnIndex: number
    itemIndex: number
    items: any[]
    fixed: VxeColumnPropTypes.Fixed
    type: string
    data: any[][]
  }

  interface TableEventParams extends VxeEvent {
    $table: VxeTableConstructor & VxeTablePrivateMethods
  }

  interface TableBaseHeaderCellParams {
    $rowIndex: number
    column: ColumnInfo
    columnIndex: number
    $columnIndex: number
  }

  interface TableBaseCellParams {
    row: any
    rowIndex: number
    $rowIndex: number
    column: ColumnInfo
    columnIndex: number
    $columnIndex: number
  }

  interface TableBaseFooterCellParams {
    $rowIndex: number
    column: ColumnInfo
    columnIndex: number
    $columnIndex: number
  }

  export interface KeydownStartParams { }
  export interface KeydownStartEventParams extends TableEventParams, KeydownStartParams { }

  export interface KeydownParams { }
  export interface KeydownEventParams extends TableEventParams, KeydownParams { }

  export interface KeydownEndParams { }
  export interface KeydownEndEventParams extends TableEventParams, KeydownEndParams { }

  export interface PasteParams { }
  export interface PasteEventParams extends TableEventParams, PasteParams { }

  export interface CopyParams { }
  export interface CopyEventParams extends TableEventParams, CopyParams { }

  export interface CutParams { }
  export interface CutEventParams extends TableEventParams, CutParams { }

  export interface CurrentChangeParams extends TableBaseCellParams {
    newValue: any
    oldValue: any
  }
  export interface CurrentChangeEventParams extends TableEventParams, CurrentChangeParams { }

  export interface RadioChangeParams extends TableBaseCellParams {
    newValue: any
    oldValue: any
  }
  export interface RadioChangeEventParams extends TableEventParams, RadioChangeParams { }

  export interface CheckboxChangeParams extends TableBaseCellParams {
    checked: boolean
    /**
     * 请调用方法 getCheckboxRecords() 获取
     * @deprecated
     */
    records: any[]
    /**
     * 请调用方法 getCheckboxReserveRecords() 获取
     * @deprecated
     */
    reserves: any[]
    /**
     * 请调用方法 getCheckboxIndeterminateRecords() 获取
     * @deprecated
     */
    indeterminates: any[]
  }
  export interface CheckboxChangeEventParams extends TableEventParams, CheckboxChangeParams { }

  export interface CheckboxAllParams extends CheckboxChangeParams { }
  export interface CheckboxAllEventParams extends TableEventParams, CheckboxAllParams { }

  export interface CheckboxRangeStartParams {
    /**
     * 请调用方法 getCheckboxRecords() 获取
     * @deprecated
     */
    records: any[]
    /**
     * 请调用方法 getCheckboxReserveRecords() 获取
     * @deprecated
     */
    reserves: any[]
  }
  export interface CheckboxRangeStartEventParams extends TableEventParams, CheckboxRangeStartParams { }

  export interface CheckboxRangeChangeParams extends CheckboxRangeStartParams { }
  export interface CheckboxRangeChangeEventParams extends TableEventParams, CheckboxRangeChangeParams { }

  export interface CheckboxRangeEndParams extends CheckboxRangeStartParams { }

  export interface CheckboxRangeEndEventParams extends TableEventParams, CheckboxRangeEndParams { }

  export interface CellClickParams extends TableBaseCellParams {
    triggerRadio: boolean
    triggerCheckbox: boolean
    triggerTreeNode: boolean
    triggerExpandNode: boolean
  }
  export interface CellClickEventParams extends TableEventParams, CellClickParams { }

  export interface CellDblclickParams extends CellClickParams, CellClickParams { }
  export interface CellDblclickEventParams extends TableEventParams, CellDblclickParams { }

  export interface CellMenuParams extends TableBaseCellParams { }
  export interface CellMenuEventParams extends TableEventParams, CellMenuParams { }

  export interface CellMouseenterParams extends TableBaseCellParams { }
  export interface CellMouseenterEventParams extends TableEventParams, CellMouseenterParams { }

  export interface CellMouseleaveParams extends TableBaseCellParams { }
  export interface CellMouseleaveEventParams extends TableEventParams, CellMouseleaveParams { }

  export interface HeaderCellClickParams extends TableBaseHeaderCellParams {
    triggerResizable: boolean
    triggerSort: boolean
    triggerFilter: boolean
  }
  export interface HeaderCellClickEventParams extends TableEventParams, HeaderCellClickParams { }

  export interface HeaderCellDblclickParams extends TableBaseHeaderCellParams { }
  export interface HeaderCellDblclickEventParams extends TableEventParams, HeaderCellDblclickParams { }

  export interface HeaderCellMenuParams extends TableBaseHeaderCellParams { }
  export interface HeaderCellMenuEventParams extends TableEventParams, HeaderCellMenuParams { }

  export interface FooterCellClickParams extends TableBaseFooterCellParams { }
  export interface FooterCellClickEventParams extends TableEventParams, FooterCellClickParams { }

  export interface FooterCellDblclickParams extends TableBaseFooterCellParams { }
  export interface FooterCellDblclickEventParams extends TableEventParams, FooterCellDblclickParams { }

  export interface FooterCellMenuParams extends TableBaseFooterCellParams { }
  export interface FooterCellMenuEventParams extends TableEventParams, FooterCellMenuParams { }

  export interface SortCheckedParams {
    column: VxeTableDefines.ColumnInfo
    field: VxeColumnPropTypes.Field
    property: VxeColumnPropTypes.Field
    order: VxeTablePropTypes.SortOrder
    sortTime: number
  }
  export interface SortChangeParams extends SortCheckedParams {
    sortList: SortCheckedParams[]
  }
  export interface SortChangeEventParams extends TableEventParams, SortChangeParams { }

  export interface FilterCheckedParams {
    column: VxeTableDefines.ColumnInfo
    field: VxeColumnPropTypes.Field
    property: VxeColumnPropTypes.Field
    values: any[]
    datas: any[]
  }
  export interface FilterChangeParams extends FilterCheckedParams {
    filterList: FilterCheckedParams[]
  }
  export interface FilterChangeEventParams extends TableEventParams, FilterChangeParams { }

  export interface FilterVisibleParams {
    column: VxeTableDefines.ColumnInfo
    field: VxeColumnPropTypes.Field
    property: VxeColumnPropTypes.Field
    filterList: FilterCheckedParams[]
    visible: boolean
  }
  export interface FilterVisibleEventParams extends TableEventParams, FilterVisibleParams { }

  export interface ResizableChangeParams extends TableBaseHeaderCellParams { }
  export interface ResizableChangeEventParams extends TableEventParams, ResizableChangeParams {
    resizeWidth: number
  }

  export interface ToggleRowExpandParams extends TableBaseCellParams { }
  export interface ToggleRowExpandEventParams extends TableEventParams, ToggleRowExpandParams { }

  export interface ToggleTreeExpandParams extends TableBaseCellParams { }
  export interface ToggleTreeExpandEventParams extends TableEventParams, ToggleTreeExpandParams { }

  export interface MenuClickParams extends TableBaseCellParams {
    menu: VxeTableDefines.MenuFirstOption | VxeTableDefines.MenuChildOption
    type: string
  }
  export interface MenuClickEventParams extends TableEventParams, MenuClickParams { }

  export interface EditClosedParams extends TableBaseCellParams { }
  export interface EditClosedEventParams extends TableEventParams, EditClosedParams { }

  export interface EditActivedParams extends TableBaseCellParams { }
  export interface EditActivedEventParams extends TableEventParams, EditActivedParams { }

  export interface EditDisabledParams extends TableBaseCellParams { }
  export interface EditDisabledEventParams extends TableEventParams, EditDisabledParams { }

  export interface ValidErrorParams extends TableBaseCellParams {
    rule: any
  }
  export interface ValidErrorEventParams extends TableEventParams, ValidErrorParams { }

  export interface ScrollParams {
    type: string
    scrollTop: number
    scrollLeft: number
    scrollHeight: number
    scrollWidth: number
    bodyWidth: number
    bodyHeight: number
    isX: boolean
    isY: boolean
  }
  export interface ScrollEventParams extends TableEventParams, ScrollParams {
    target: HTMLDivElement
  }

  export interface CustomParams {
    type: string
  }
  export interface CustomEventParams extends TableEventParams, 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 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 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
}