vxe-pc-ui/types/components/table.d.ts

A vue based PC component library

import { RenderFunction, SetupContext, Ref, ComputedRef, ComponentPublicInstance, VNode } from 'vue'
import { DefineVxeComponentApp, DefineVxeComponentOptions, DefineVxeComponentInstance, VxeComponentBaseOptions, VxeComponentEventParams, VxeComponentSizeType, ValueOf, VxeGlobalConfig, VxeComponentStyleType, VxeComponentSlotType, VxeComponentAlignType } from '@vxe-ui/core'
import { VxeColumnPropTypes, VxeColumnProps, VxeColumnSlotTypes } from './column'
import { VxeTableExtendCellAreaDefines, VxeTableExtendCellAreaEmits } from './table-plugins'
import { VxeGridConstructor } from './grid'
import { VxeTooltipInstance, VxeTooltipPropTypes } from './tooltip'
import { VxeModalPropTypes } from './modal'
import { VxeDrawerPropTypes } from './drawer'
import { VxeToolbarConstructor, VxeToolbarInstance } from './toolbar'
import { VxeTableCustomPanelConstructor } from './table-module/custom'
import { VxeGanttConstructor, VxeGanttPrivateMethods } from './gantt'
import { VxeGanttViewConstructor, VxeGanttViewInstance, VxeGanttViewPrivateMethods } from './gantt-module/gantt-view'

/* eslint-disable no-use-before-define,@typescript-eslint/ban-types */

export declare const VxeTable: DefineVxeComponentApp<VxeTableProps, VxeTableEventProps, VxeTableSlots, VxeTableMethods>
export type VxeTableComponent = DefineVxeComponentOptions<VxeTableProps, VxeTableEventProps>

export type VxeTableInstance<D = any> = DefineVxeComponentInstance<VxeTableProps<D>, VxeTableConstructor>

export interface VxeTableConstructor<D = any> extends VxeComponentBaseOptions, VxeTableMethods {
  props: VxeTableProps
  context: SetupContext<VxeTableEmits>
  /**
   * 组件内部属性
   * @private
   */
  reactData: TableReactData
  /**
   * 组件内部属性
   * @private
   */
  internalData: TableInternalData<D>
  getRefMaps(): TablePrivateRef
  getComputeMaps(): TablePrivateComputed
  renderVN: RenderFunction

  xeGrid: VxeGridConstructor<D> | null | undefined
  xeGantt: VxeTableDefines.InjectGanttType<D> | null | undefined

  /**
   * @deprecated
   */
  xegrid: VxeGridConstructor<D> | null | undefined
}

export interface TablePrivateRef {
  refElem: Ref<HTMLDivElement>
  refTooltip: Ref<VxeTooltipInstance>
  refValidTooltip: Ref<VxeTooltipInstance>
  refTableFilter: Ref<any>
  refTableCustom: Ref<VxeTableCustomPanelConstructor>
  refTableMenu: Ref<any>
  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>
  refColResizeBar: Ref<HTMLDivElement>
  refRowResizeBar: Ref<HTMLDivElement>
  refScrollXVirtualElem: Ref<HTMLDivElement | undefined>
  refScrollYVirtualElem: Ref<HTMLDivElement | undefined>
  refScrollXHandleElem: Ref<HTMLDivElement | undefined>
  refScrollYHandleElem: Ref<HTMLDivElement | undefined>
  refScrollXSpaceElem: Ref<HTMLDivElement | undefined>
  refScrollYSpaceElem: Ref<HTMLDivElement | undefined>
}

export interface VxeTablePrivateRef extends TablePrivateRef { }

/**
 * 已废弃，被 VxeTablePropTypes.Row 替换
 * @deprecated
 */
export type VxeTableDataRow = VxeTablePropTypes.Row

export namespace VxeTablePropTypes {
  export type Size = VxeComponentSizeType
  export type ID<D = any> = string | ((params: {
    $table: VxeTableConstructor<D>
    $grid: VxeGridConstructor<D> | null | undefined
    $gantt: VxeGanttConstructor | null | undefined
  }) => string | number | null)

  export interface Row {
    [key: string]: any
  }

  export type Data<T = Row> = T[]
  export type Height = number | string
  export type MinHeight = number | string
  export type MaxHeight = number | string
  export type Resizable = boolean
  export type Stripe = boolean
  export type Round = boolean
  export type Padding = boolean
  export type Border = boolean | 'default' | 'full' | 'outer' | 'inner' | 'none' | ''
  export type Loading = boolean
  export type Align = VxeComponentAlignType
  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 FooterData = Record<string, any>[]

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

  export type RowClassName<D = VxeTablePropTypes.Row> = string | ((params: {
    $table: VxeTableConstructor<D>
    row: D
    rowIndex: number
    $rowIndex: number
    _rowIndex: number
  }) => void | null | string | { [key: string]: boolean | null | undefined })

  export type CellClassName<D = VxeTablePropTypes.Row> = string | ((params: {
    $table: VxeTableConstructor<D>
    row: D
    rowIndex: number
    $rowIndex: number
    _rowIndex: number
    column: VxeTableDefines.ColumnInfo<D>
    columnIndex: number
    $columnIndex: number
    _columnIndex: number
  }) => void | null | string | { [key: string]: boolean | null | undefined })

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

  export type HeaderCellClassName<D = VxeTablePropTypes.Row> = string | ((params: {
    $table: VxeTableConstructor<D>
    $rowIndex: number
    column: VxeTableDefines.ColumnInfo<D>
    columnIndex: number
    $columnIndex: number
    _columnIndex: number
    fixed: VxeColumnPropTypes.Fixed
    type: string
  }) => void | null | string | { [key: string]: boolean | null | undefined })

  export type FooterRowClassName<D = VxeTablePropTypes.Row> = string | ((params: {
    $table: VxeTableConstructor<D>
    row: D
    $rowIndex: number
    _rowIndex: number
    fixed: VxeColumnPropTypes.Fixed
    type: string
  }) => void | null | string | { [key: string]: boolean | null | undefined })

  export type FooterCellClassName<D = VxeTablePropTypes.Row> = string | ((params: {
    $table: VxeTableConstructor<D>
    row: D
    $rowIndex: number
    _rowIndex: number
    column: VxeTableDefines.ColumnInfo<D>
    columnIndex: number
    $columnIndex: number
    _columnIndex: number
  }) => void | null | string | { [key: string]: boolean | null | undefined })

  export type CellStyle<D = VxeTablePropTypes.Row> = Partial<CSSStyleDeclaration> | ((params: {
    row: D
    rowIndex: number
    $rowIndex: number
    _rowIndex: number
    column: VxeTableDefines.ColumnInfo<D>
    columnIndex: number
    $columnIndex: number
    _columnIndex: number
  }) => void | null | Partial<CSSStyleDeclaration> |VxeComponentStyleType)

  export type HeaderCellStyle<D = VxeTablePropTypes.Row> = Partial<CSSStyleDeclaration> | ((params: {
    $table: VxeTableConstructor<D>
    $rowIndex: number
    column: VxeTableDefines.ColumnInfo<D>
    columnIndex: number
    _columnIndex: number
  }) => void | null | Partial<CSSStyleDeclaration> |VxeComponentStyleType)

  export type FooterCellStyle<D = any> = VxeComponentStyleType | ((params: {
    $table: VxeTableConstructor<D>
    row: D
    $rowIndex: number
    column: VxeTableDefines.ColumnInfo<D>
    columnIndex: number
    $columnIndex: number
    _columnIndex: number
  }) => void | null | Partial<CSSStyleDeclaration> |VxeComponentStyleType)

  export type RowStyle<D = VxeTablePropTypes.Row> = Partial<CSSStyleDeclaration> | ((params: {
    $table: VxeTableConstructor<D>
    row: D
    rowIndex: number
    $rowIndex: number
    _rowIndex: number
  }) => void | null | Partial<CSSStyleDeclaration> |VxeComponentStyleType)

  export type HeaderRowStyle<D = VxeTablePropTypes.Row> = Partial<CSSStyleDeclaration> | ((params: {
    $table: VxeTableConstructor<D>
    $rowIndex: number
    fixed: VxeColumnPropTypes.Fixed
    type: string
  }) => void | null | Partial<CSSStyleDeclaration> |VxeComponentStyleType)

  export type FooterRowStyle<D = any> = Partial<CSSStyleDeclaration> | ((params: {
    $table: VxeTableConstructor<D>
    row: D
    $rowIndex: number
    _rowIndex: number
    fixed: VxeColumnPropTypes.Fixed
    type: string
  }) => void | null | Partial<CSSStyleDeclaration> | VxeComponentStyleType)

  export type ShowCustomHeader = boolean

  export type MergeHeaderCells = VxeTableDefines.MergeOptions[]
  export type MergeCells<D = VxeTablePropTypes.Row> = VxeTableDefines.MergeOptions<D>[]
  export type MergeFooterCells<D = any> = VxeTableDefines.MergeOptions<D>[]

  /**
   * @deprecated
   */
  export type MergeCell<D = VxeTablePropTypes.Row> = VxeTableDefines.MergeOptions<D>
  /**
   * @deprecated
   */
  export type MergeFooterItem<D = any> = VxeTableDefines.MergeOptions<D>
  /**
   * 已废弃，请使用 VxeTablePropTypes.MergeFooterCells
   * @deprecated
   */
  export type MergeFooterItems<D = any> = VxeTableDefines.MergeOptions<D>[]

  export type SpanMethod<D = VxeTablePropTypes.Row> = (params: {
    $table: VxeTableConstructor<D>
    column: VxeTableDefines.ColumnInfo<D>
    columnIndex: number
    $columnIndex: number
    row: D
    rowIndex: number
    $rowIndex: number
    _rowIndex: number
    isHidden: boolean
    fixed: VxeColumnPropTypes.Fixed
    type: string
    visibleData: D[]
  }) => void | { rowspan: number, colspan: number }

  export type FooterSpanMethod<D = any> = (params: {
    $table: VxeTableConstructor<D>
    column: VxeTableDefines.ColumnInfo<D>
    columnIndex: number
    _columnIndex: number
    $columnIndex: number
    row: D
    $rowIndex: number
    _rowIndex: number
    items: any[]
    data: D[][]
  }) => 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<D = any> {
    /**
     * 是否需要为每一列的 VNode 设置 key 属性
     */
    useKey?: boolean
    /**
     * 当鼠标点击列头时，是否要高亮当前列
     */
    isCurrent?: boolean
    /**
     * 当鼠标移到列头时，是否要高亮当前头
     */
    isHover?: boolean
    /**
     * 已废弃，请使用 current-column-config.beforeSelectMethod
     * @deprecated
     */
    currentMethod?(params: {
      column: VxeTableDefines.ColumnInfo<D>
    }): boolean
    /**
     * 每一列是否启用列宽调整
     */
    resizable?: VxeColumnPropTypes.Resizable
    /**
     * 每一列的宽度
     */
    width?: VxeColumnPropTypes.Width
    /**
     * 每一列的最小宽度
     */
    minWidth?: VxeColumnPropTypes.MinWidth
    /**
     * 每一列的最大宽度
     */
    maxWidth?: VxeColumnPropTypes.MaxWidth
    /**
     * 用于 column.width=auto | column.min-width=auto 自适应单元格宽度参数
     */
    autoOptions?: {
      /**
       * 是否启用自适应表头单元格宽度
       */
      isCalcHeader?: boolean
      /**
       * 是否启用自适应表体单元格宽度
       */
      isCalcBody?: boolean
      /**
       * 是否启用自适应表尾单元格宽度
       */
      isCalcFooter?: boolean
    }
    /**
     * 固定列允许设置的最大数量（如果是分组，则一个分组算一个）
     */
    maxFixedSize?: number
    /**
     * 是否启用列拖拽排序
     */
    drag?: boolean
    /**
     * 每一列的自定义表头单元格数据导出方法，返回自定义的标题
     */
    headerExportMethod?: VxeColumnPropTypes.HeaderExportMethod<any>
    /**
     * 每一列的自定义单元格数据导出方法，返回自定义的值
     */
    exportMethod?: VxeColumnPropTypes.ExportMethod<any>
    /**
     * 每一列的自定义表尾单元格数据导出方法，返回自定义的值
     */
    footerExportMethod?: VxeColumnPropTypes.FooterExportMethod<any>
  }
  export interface ColumnOpts<D = any> extends ColumnConfig<D> { }

  /**
   * 行配置信息
   */
  export interface RowConfig<D = any> {
    /**
     * 是否需要为每一行的 VNode 设置 key 属性
     */
    useKey?: boolean
    /**
     * 自定义行数据唯一主键的字段名（默认自动生成）
     */
    keyField?: string
    /**
     * 自定义行主键生成的方法
     */
    createKeyMethod?(params: {
      row: D
      keyField: string
    }): string | number
    /**
     * 当鼠标点击行时，是否要高亮当前行
     */
    isCurrent?: boolean
    /**
     * 已废弃，请使用 current-row-config.beforeSelectMethod
     * @deprecated
     */
    currentMethod?(params: {
      row: D
    }): boolean
    /**
     * 当鼠标移到行时，是否要高亮当前行
     */
    isHover?: boolean
    /**
     * 每一行开启调整行高度
     */
    resizable?: boolean
    /**
     * 已废弃，被 cell-config.height 替换
     * @deprecated
     */
    height?: number
    /**
     * 是否启用行拖拽排序
     */
    drag?: boolean
  }
  export interface RowOpts<D = any> extends RowConfig<D> { }

  /**
   * 数据聚合配置项
   */
  export interface AggregateConfig<D = any> {
    /**
     * 分组列展示方式
     */
    mode?: 'column' | 'default' | '' | null
    /**
     * 按指定字段对数据进行分组
     */
    groupFields?: string[]
    /**
     * 是否显示边距
     */
    padding?: boolean
    /**
     * 对于同一级的节点，每次只能展开一个
     */
    accordion?: boolean
    /**
     * 分组节点的字段名
     */
    rowField?: string
    /**
     * 分组父节点的字段名
     */
    parentField?: string
    /**
     * 分组子节点的字段名
     */
    childrenField?: string
    /**
     * 分组子节点映射的字段名
     */
    mapChildrenField?: string
    /**
     * 默认展开所有分组行（只会在初始化时被触发一次）
     */
    expandAll?: boolean
    /**
     * 默认展开指定分组行的字段（只会在初始化时被触发一次）
     */
    expandGroupFields?: string[]
    /**
     * 分组节点的缩进
     */
    indent?: number
    /**
     * 触发方式
     */
    trigger?: 'default' | 'row' | 'cell' | 'manual' | '' | null
    /**
     * 是否显示图标按钮
     */
    showIcon?: boolean
    /**
     * 自定义展开后显示的图标
     */
    iconOpen?: string
    /**
     * 自定义收起后显示的图标
     */
    iconClose?: string
    /**
     * 是否显示分组的统计
     */
    showTotal?: boolean
    /**
     * 是否显示聚合函数的列标题
     */
    showAggFuncTitle?: boolean
    /**
     * 聚合函数默认值初始化的方法，当聚合列被创建时会执行一次
     */
    initialAggFuncMethod?:(params: {
      $table: VxeTableConstructor<D>
      column: VxeTableDefines.ColumnInfo<D>
    }) => VxeTableDefines.AggFuncType
    /**
     * 数据分组允许设置的最大数量
     */
    maxGroupSize?: number
    /**
     * 指定哪些列允许拖拽到分组
     */
    includeGroupFields?: string[]
    /**
     * 排除哪些列允许拖拽到分组
     */
    excludeGroupFields?: string[]
    /**
     * 指定哪些列允许拖拽到值
     */
    includeValuesFields?: string[]
    /**
     * 排除哪些列允许拖拽到值
     */
    excludeValuesFields?: string[]
    /**
     * 自定义列聚合数据的计算方法
     */
    calcValuesMethod?:(params: {
      $table: VxeTableConstructor<D>
      groupField: VxeColumnPropTypes.Field
      groupColumn: VxeTableDefines.ColumnInfo<D>
      column: VxeTableDefines.ColumnInfo<D>
      groupValue: any
      childCount: number
      children: D[]
      aggValue: number
    }) => number
    /**
     * 自定义列聚合数据的显示值
     */
    formatValuesMethod?:(params: {
      $table: VxeTableConstructor<D>
      groupField: VxeColumnPropTypes.Field
      groupColumn: VxeTableDefines.ColumnInfo<D>
      column: VxeTableDefines.ColumnInfo<D>
      groupValue: any
      childCount: number
      children: D[]
      aggValue: number
    }) => number | string
    /**
     * 自定义分组统计的方法
     */
    totalMethod?:(params: {
      $table: VxeTableConstructor<D>
      groupField: VxeColumnPropTypes.Field
      groupColumn: VxeTableDefines.ColumnInfo<D>
      column: VxeTableDefines.ColumnInfo<D>
      groupValue: any
      childCount: number
      children: D[]
    }) => number | string
    /**
     * 自定义分组单元格展示内容
     */
    contentMethod?:(params: {
      $table: VxeTableConstructor<D>
      groupField: VxeColumnPropTypes.Field
      groupColumn: VxeTableDefines.ColumnInfo<D>
      column: VxeTableDefines.ColumnInfo<D>
      groupValue: any
    }) => number | string

    /**
     * 已废弃，请使用 column.aggFunc
     * @deprecated
     */
    countFields?: string[]
    /**
     * 请使用 calcValuesMethod
     * @deprecated
     */
    aggregateMethod?:(params: {
      $table: VxeTableConstructor<D>
      groupField: VxeColumnPropTypes.Field
      groupColumn: VxeTableDefines.ColumnInfo<D>
      column: VxeTableDefines.ColumnInfo<D>
      groupValue: any
      childCount: number
      aggValue: any
      children: D[]
    }) => number
    /**
     * 已废弃，请使用 calcValuesMethod
     * @deprecated
     */
    countMethod?:(params: {
      $table: VxeTableConstructor<D>
      groupField: VxeColumnPropTypes.Field
      groupColumn: VxeTableDefines.ColumnInfo<D>
      column: VxeTableDefines.ColumnInfo<D>
      groupValue: any
      childCount: number
      children: D[]
    }) => number
  }

  /**
   * 聚合函数计算精度配置项
   */
  export interface AggregateAccuracyConfig<D = any> {
    [key: string]: VxeTableDefines.AggregateAccuracyObj<D>
  }

  /**
   * 已废弃，请使用 AggregateConfig
   * @deprecated
   */
  export interface RowGroupConfig<D = any> extends AggregateConfig<D> {}

  /**
   * 当前行配置项
   */
  export interface CurrentRowConfig<D = any> {
    /**
     * 触发方式
     */
    trigger?: 'default' | 'row' | 'manual' | '' | null
    /**
     * 严格模式，选中后不能取消
     */
    strict?: boolean
    /**
     * 只对 mouse-config.selected 启用有效，是否跟随单元格选中而移动高亮行
     */
    isFollowSelected?: boolean
    /**
     * 用于选中当前行执行之前的方法，返回 false 可以阻止默认行为
     */
    beforeSelectMethod?(params: {
      $table: VxeTableConstructor<D>
      row: D
      selected: boolean
    }): boolean
  }

  /**
   * 当前列配置项
   */
  export interface CurrentColumnConfig<D = any> {
    /**
     * 触发方式
     */
    trigger?: 'default' | 'header' | 'cell' | 'manual' | '' | null
    /**
     * 严格模式，选中后不能取消
     */
    strict?: boolean
    /**
     * 只对 mouse-config.selected 启用有效，是否跟随单元格选中而移动高亮列
     */
    isFollowSelected?: boolean
    /**
     * 用于选中当前列执行之前的方法，返回 false 可以阻止默认行为
     */
    beforeSelectMethod?(params: {
      $table: VxeTableConstructor<D>
      column: VxeTableDefines.ColumnInfo<D>
      selected: boolean
    }): boolean
  }

  /**
   * 单元格配置项
   */
  export interface CellConfig<D = any>{
    /**
     * 单元格默认高度
     */
    height?: number
    /**
     * 是否显示间距
     */
    padding?: VxeColumnPropTypes.Padding
    /**
     * 垂直对齐方式
     */
    verticalAlign?: VxeColumnPropTypes.VerticalAlign
  }

  /**
   * 表头单元格配置项
   */
  export interface HeaderCellConfig<D = any>{
    /**
     * 单元格默认高度
     */
    height?: number | 'unset'
    /**
     * 是否显示间距
     */
    padding?: boolean
  }

  /**
   * 表尾单元格配置项
   */
  export interface FooterCellConfig<D = any>{
    /**
     * 单元格默认高度
     */
    height?: number | 'unset'
    /**
     * 是否显示间距
     */
    padding?: boolean
  }

  /**
   * 已废弃，被 RowDragConfig 替换
   * @deprecated
   */
  export interface DragConfig<D = any>{
    /**
     * 自定义图标
     * @deprecated
     */
    rowIcon?: string
    /**
     * 是否显示拖拽按钮图标
     * @deprecated
     */
    showRowIcon?: boolean
    /**
     * 是否禁用拖拽按钮
     * @deprecated
     */
    rowDisabledMethod?(params: {
      row: D
      column: VxeTableDefines.ColumnInfo<D>
    }): boolean
    /**
     * 是否显示拖拽按钮
     * @deprecated
     */
    rowVisibleMethod?(params: {
      row: D
      column: VxeTableDefines.ColumnInfo<D>
    }): boolean
    /**
     * 自定义提示内容
     * @deprecated
     */
    rowTooltipMethod?(params: {
      row: D
    }): string | number | null
    /**
     * 拖拽开始时是否允许行拖拽调整顺序的方法，该方法的返回值用来决定是否允许被拖拽
     * @deprecated
     */
    dragStartMethod?(params: VxeTableDefines.RowDragstartEventParams<D>): boolean
    /**
     * 拖拽结束时是否允许行拖拽调整顺序的方法，该方法的返回值用来决定是否允许被拖拽调整顺序
     * @deprecated
     */
    dragEndMethod?(params: Omit<VxeTableDefines.RowDragendEventParams<D>, '_index'>): Promise<boolean> | boolean
    /**
     * 自定义插槽模板
     * @deprecated
     */
    slots?: {
      rowTip?: string | ((params: VxeTableDefines.RowDragSlotParams) => VxeComponentSlotType | VxeComponentSlotType[])
    }
  }

  /**
   * 行拖拽排序配置项
   */
  export interface RowDragConfig<D = any>{
    /**
     * 自定义图标
     */
    icon?: string
    /**
     * 是否显示拖拽按钮图标
     */
    showIcon?: boolean
    /**
     * 显示拖拽提示，拖拽过程中显示信息
     */
    showDragTip?: boolean
    /**
     * 触发拖拽方式
     */
    trigger?: 'default' | 'cell' | 'row' | '' | null
    /**
     * 只对 tree-config 启用有效，是否允许同级行拖拽，用于树结构，启用后允许同层级之间进行拖拽
     */
    isPeerDrag?: boolean
    /**
     * 只对 tree-config 启用有效，是否允许同级/跨层行拖拽，用于树结构，启用后允许跨层级拖拽（除了上级拖到子级）
     */
    isCrossDrag?: boolean
    /**
     * 需要 isCrossDrag，只对 tree-config 启用有效，是否允许拖拽成目标行的子级
     */
    isToChildDrag?: boolean
    /**
     * 需要 isCrossDrag，只对 tree-config 启用有效，是否允许将自己拖拽到子级行中
     */
    isSelfToChildDrag?: boolean
    /**
     * 是否允许在不同表格之间进行拖拽
     */
    isCrossTableDrag?: boolean
    /**
     * 是否显示拖拽辅助状态显示
     */
    showGuidesStatus?: boolean
    /**
     * 是否显示拖拽动画，启用后由数据量的大小来影响渲染性能
     */
    animation?: boolean
    /**
     * 是否禁用拖拽按钮
     */
    disabledMethod?(params: {
      $table: VxeTableConstructor<D>
      row: D
      column: VxeTableDefines.ColumnInfo<D>
    }): boolean
    /**
     * 是否显示拖拽按钮
     */
    visibleMethod?(params: {
      $table: VxeTableConstructor<D>
      row: D
      column: VxeTableDefines.ColumnInfo<D>
    }): boolean
    /**
     * 自定义提示内容
     */
    tooltipMethod?(params: {
      $table: VxeTableConstructor<D>
      row: D
    }): string | number | null
    /**
     * 拖拽开始时是否允许行拖拽调整顺序的方法，该方法的返回值用来决定是否允许被拖拽
     */
    dragStartMethod?(params: VxeTableDefines.RowDragstartEventParams<D>): boolean
    /**
     * 拖拽结束时是否允许行拖拽调整顺序的方法，该方法的返回值用来决定是否允许被拖拽调整顺序
     */
    dragEndMethod?(params: Omit<VxeTableDefines.RowDragendEventParams<D>, '_index'>): Promise<boolean> | boolean
    /**
     * 用于 isToChildDrag，在拖拽完成后，该方法的返回值用于决定是否拖拽成子级
     */
    dragToChildMethod?(params: Omit<VxeTableDefines.RowDragToChildMethod<D>, '_index'>): boolean
    /**
     * 自定义插槽模板
     */
    slots?: {
      tip?: string | ((params: VxeTableDefines.RowDragSlotParams) => VxeComponentSlotType | VxeComponentSlotType[])
    }
  }

  /**
   * 列拖拽排序配置项
   */
  export interface ColumnDragConfig<D = any>{
    /**
     * 自定义图标
     */
    icon?: string
    /**
     * 是否显示拖拽按钮图标
     */
    showIcon?: boolean
    /**
     * 显示拖拽提示，拖拽过程中显示信息
     */
    showDragTip?: boolean
    /**
     * 触发拖拽方式
     */
    trigger?: 'default' | 'cell' | '' | null
    /**
     * 用于分组表头，是否允许同级列拖拽，启用后允许同层级列之间进行拖拽
     */
    isPeerDrag?: boolean
    /**
     * 需要 isCrossDrag，用于分组表头，是否同级/跨层列拖拽，启用后允许跨拖拽列拖拽（除了上级拖到子级）
     */
    isCrossDrag?: boolean
    /**
     * 需要 isCrossDrag，是否允许拖拽成目标列的子级
     */
    isToChildDrag?: boolean
    /**
     * 用于分组表头，是否允许将自己拖拽到子孙列中
     */
    isSelfToChildDrag?: boolean
    /**
     * 是否显示拖拽辅助状态显示
     */
    showGuidesStatus?: boolean
    /**
     * 是否显示拖拽动画，启用后由数据量的大小来影响渲染性能
     */
    animation?: boolean
    /**
     * 是否禁用拖拽按钮
     */
    disabledMethod?(params: {
      $table: VxeTableConstructor<D>
      column: VxeTableDefines.ColumnInfo<D>
    }): boolean
    /**
     * 是否显示拖拽按钮
     */
    visibleMethod?(params: {
      $table: VxeTableConstructor<D>
      column: VxeTableDefines.ColumnInfo<D>
    }): boolean
    /**
     * 自定义提示内容
     */
    tooltipMethod?(params: {
      $table: VxeTableConstructor<D>
      column: VxeTableDefines.ColumnInfo<D>
    }): string | number | null
    /**
     * 拖拽开始时是否允许行拖拽调整顺序的方法，该方法的返回值用来决定是否允许被拖拽
     */
    dragStartMethod?(params: VxeTableDefines.ColumnDragstartEventParams<D>): boolean
    /**
     * 拖拽结束时是否允许行拖拽调整顺序的方法，该方法的返回值用来决定是否允许被拖拽调整顺序
     */
    dragEndMethod?(params: Omit<VxeTableDefines.ColumnDragendEventParams<D>, '_index'>): Promise<boolean> | boolean
    /**
     * 用于 isToChildDrag，在拖拽完成后，该方法的返回值用于决定是否拖拽成子级
     */
    dragToChildMethod?(params: Omit<VxeTableDefines.ColumnDragToChildMethod<D>, '_index'>): boolean
    /**
     * 自定义插槽模板
     */
    slots?: {
      tip?: string | ((params: VxeTableDefines.ColumnDragSlotParams) => VxeComponentSlotType | VxeComponentSlotType[])
    }
  }

  /**
   * 自定义列配置项
   */
  export interface CustomConfig<D = VxeTablePropTypes.Row> {
    /**
     * 是否启用，支持局部/全局启用
     */
    enabled?: boolean
    /**
     * 是否启用 localStorage 本地保存，会将列操作状态保留在本地（需要有 id）
     */
    storage?: boolean | VxeTableDefines.VxeTableCustomStorageObj
    /**
     * 只对 storage 有效，缓存项的配置
     */
    storeOptions?: VxeTableDefines.VxeTableCustomStorageObj
    /**
     * 只对 storage 有效，用于重写默认的恢复自定义配置逻辑，用于实现服务端保存
     */
    restoreStore?(params: {
      $table: VxeTableConstructor<D>
      id: string
      type: 'restore'
      storeData: VxeTableDefines.CustomStoreData
    }): VxeTableDefines.CustomStoreData | Promise<VxeTableDefines.CustomStoreData>
    /**
     * 只对 storage 有效，重写默认的保存方法，用于实现服务端保存
     */
    updateStore?(params: {
      $table: VxeTableConstructor<D>
      id: string
      type: VxeTableDefines.CustomEventType
      storeData: VxeTableDefines.CustomStoreData
    }): Promise<any>
    mode?: 'default' | 'modal' | 'drawer' | 'simple' | 'popup' | '' | null
    /**
     * 窗口模式配置项，用于 mode='modal'
     */
    modalOptions?: {
      title?: VxeModalPropTypes.Title
      width?: VxeModalPropTypes.Width
      minWidth?: VxeModalPropTypes.MinWidth
      height?: VxeModalPropTypes.Height
      minHeight?: VxeModalPropTypes.MinHeight
      className?: VxeModalPropTypes.ClassName
      showZoom?: VxeModalPropTypes.ShowZoom
      showMaximize?: VxeModalPropTypes.ShowMaximize
      showMinimize?: VxeModalPropTypes.ShowMinimize
      mask?: VxeModalPropTypes.Mask
      lockView?: VxeModalPropTypes.LockView
      resize?: VxeModalPropTypes.Resize
      escClosable?: VxeModalPropTypes.EscClosable
      maskClosable?: VxeModalPropTypes.MaskClosable
    }
    /**
     * 抽屉模式配置项，用于 mode='drawer'
     */
    drawerOptions?: {
      title?: VxeDrawerPropTypes.Title
      width?: VxeDrawerPropTypes.Width
      className?: VxeDrawerPropTypes.ClassName
      position?: VxeDrawerPropTypes.Position
      mask?: VxeDrawerPropTypes.Mask
      lockView?: VxeDrawerPropTypes.LockView
      resize?: VxeDrawerPropTypes.Resize
      escClosable?: VxeDrawerPropTypes.EscClosable
      maskClosable?: VxeDrawerPropTypes.MaskClosable
    }
    /**
     * 默认模式配置项
     */
    popupOptions?: {
      mode?: 'inside' | 'outside' | 'auto' | '' | null
      width?: number | string
      maxHeight?: number | string
    }
    trigger?: 'manual' | 'hover' | 'click' | '' | null
    /**
     * 是否实时同步操作
     */
    immediate?: boolean
    placement?: 'left' | 'right' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right'
    /**
     * 自定义列是否允许列选中的方法，该方法的返回值用来决定这一列的 checkbox 是否可以选中
     */
    checkMethod?(params: {
      $table: VxeTableConstructor<D>
      column: VxeTableDefines.ColumnInfo<D>
    }): boolean
    /**
     * 自定义列是否的方法，该方法的返回值用来决定这一列是否显示
     */
    visibleMethod?(params: {
      $table: VxeTableConstructor<D>
      column: VxeTableDefines.ColumnInfo<D>
    }): boolean
    /**
     * 是否允许个性化列显示与隐藏
     */
    allowVisible?: boolean
    /**
     * 是否允许自定义冻结列
     */
    allowFixed?: boolean
    /**
     * 是否允许自定义排序
     */
    allowSort?: boolean
    /**
     * 是否允许自定义调整列宽
     */
    allowResizable?: boolean
    /**
     * 允许自定义聚合分组配置
     */
    allowGroup?: boolean
    /**
     * 允许自定义聚合函数配置
     */
    allowValues?: boolean
    /**
     * 允许自定义聚合函数小数精度配置
     */
    allowValueDigits?: boolean
    /**
     * 允许自定义聚合函数格式化配置
     */
    allowValueFormat?: boolean
    /**
     * 当拖拽数据分组或聚合列时，自动更新列可视状态
     */
    autoAggGroupValues?: boolean
    showFooter?: boolean
    icon?: string
    resetButtonText?: string
    closeButtonText?: string
    cancelButtonText?: string
    confirmButtonText?: string

    /**
     * 自定义列的插槽模板
     */
    slots?: {
      header?: string | ((params: VxeTableDefines.CustomSlotParams) => VxeComponentSlotType | VxeComponentSlotType[])
      top?: string | ((params: VxeTableDefines.CustomSlotParams) => VxeComponentSlotType | VxeComponentSlotType[])
      bottom?: string | ((params: VxeTableDefines.CustomSlotParams) => VxeComponentSlotType | VxeComponentSlotType[])
      default?: string | ((params: VxeTableDefines.CustomSlotParams) => VxeComponentSlotType | VxeComponentSlotType[])
      footer?: string | ((params: VxeTableDefines.CustomSlotParams) => VxeComponentSlotType | VxeComponentSlotType[])
    }
  }
  export interface CustomOpts<D = VxeTablePropTypes.Row> extends CustomConfig<D> { }

  /**
   * 调整列宽和行高整配置项
   */
  export interface ResizableConfig<D = VxeTablePropTypes.Row> {
    /**
     * 拖拽模式，如果是列拖拽，则支持自适应和固定模式
     */
    dragMode?: 'auto' | 'fixed' | ''
    /**
     * 所有单元格默认允许拖拽调整行高
     */
    isAllRowDrag?: boolean
    /**
     * 所有单元格默认允许拖拽调整列宽
     */
    isAllColumnDrag?: boolean
    /**
     * 显示列宽拖拽提示，拖拽过程中实时显示列宽
     */
    showDragTip?: boolean
    /**
     * 双击自适应列宽，启用后双击拖拽线，自动根据整列的内容自适应调整列宽
     */
    isDblclickAutoWidth?: boolean
    /**
     * 双击自适应行高，启用后双击拖拽线，自动根据整列的内容自适应调整行高
     */
    isDblclickAutoHeight?: boolean
    /**
     * 当拖拽调整列宽时，是否自动同步更新所选区域的所有列宽
     */
    isSyncAutoWidth?: boolean
    /**
     * 当拖拽调整行高时，是否自动同步更新所选区域的所有行高
     */
    isSyncAutoHeight?: boolean
    /**
     * 行高拖动的最小高度
     */
    minHeight?: number | string | ((params: {
      $table: VxeTableConstructor<D>
      column: VxeTableDefines.ColumnInfo<D>
      columnIndex: number
      $columnIndex: number
      $rowIndex: number
      rowIndex: number
      row: any
    }) => number | string)
    /**
     * 行高拖动的最大高度
     */
    maxHeight?: number | string | ((params: {
      $table: VxeTableConstructor<D>
      column: VxeTableDefines.ColumnInfo<D>
      columnIndex: number
      $columnIndex: number
      $rowIndex: number
      rowIndex: number
      row: any
    }) => number | string)
    /**
     * 列宽拖动的最小宽度
     */
    minWidth?: number | string | ((params: {
      $table: VxeTableConstructor<D>
      column: VxeTableDefines.ColumnInfo<D>
      columnIndex: number
      $columnIndex: number
      $rowIndex: number
      cell?: HTMLElement
    }) => number | string)
    /**
     * 列宽拖动的最大宽度
     */
    maxWidth?: number | string | ((params: {
      $table: VxeTableConstructor<D>
      column: VxeTableDefines.ColumnInfo<D>
      columnIndex: number
      $columnIndex: number
      $rowIndex: number
      cell?: HTMLElement
    }) => number | string)
  }
  export interface ResizableOpts<D = VxeTablePropTypes.Row> extends ResizableConfig<D> { }

  /**
   * 序号配置项
   */
  export interface SeqConfig<D = VxeTablePropTypes.Row> {
    startIndex?: number
    seqMethod?(params: {
      $table: VxeTableConstructor<D>
      column: VxeTableDefines.ColumnInfo<D>
      columnIndex: number
      $columnIndex: number
      row: D
      rowIndex: number
      $rowIndex: number
    }): number | string
  }
  export interface SeqOpts<D = VxeTablePropTypes.Row> extends SeqConfig<D> { }

  interface SortConfigDefaultSort {
    field: string
    order: SortOrder
  }

  /**
   * 排序配置项
   */
  export interface SortConfig<D = VxeTablePropTypes.Row> {
    defaultSort?: SortConfigDefaultSort | SortConfigDefaultSort[]
    orders?: SortOrder[]
    sortMethod?(params: {
      $table: VxeTableConstructor<D>
      data: D[]
      sortList: VxeTableDefines.SortCheckedParams[]
    }): any[]
    /**
     * 是否使用服务端排序，如果设置为 true 则不会对数据进行处理
     */
    remote?: boolean
    /**
     * 是否允许多列排序
     */
    multiple?: boolean
    /**
     * 只对 multiple 有效，是否按照先后触发顺序进行排序
     */
    chronological?: boolean
    /**
     * 只对 allowBtn 有效，是否启用当点击排序图标时，如果与当前一致，则取消排序
     */
    allowClear?: boolean
    /**
     * 是否允许点击排序图标进行操作
     */
    allowBtn?: boolean
    trigger?: 'default' | 'cell'
    /**
     * 只对 tree-config.transform 有效，是否允许同时排序子孙层级
     */
    isDeep?: boolean
    /**
     * 是否显示排序按钮图标
     */
    showIcon?: boolean
    /**
     * 排序按钮图标的显示方法，该方法的返回值用于决定该列是否显示排序按钮图标
     * @param params
     */
    iconVisibleMethod?(params: {
      $table: VxeTableConstructor<D>
      column: VxeTableDefines.ColumnInfo<D>
    }): boolean
    /**
     * 自定义列头升级按钮的 title 提示语
     */
    ascTitle?: string | number
    /**
     * 自定义列头倒序按钮的 title 提示语
     */
    descTitle?: string | number
    iconLayout?: 'horizontal' | 'vertical'
    iconAsc?: string
    iconDesc?: string
  }
  export type SortOrder = 'asc' | 'desc' | '' | null
  export interface SortOpts<D = VxeTablePropTypes.Row> extends SortConfig<D> {
    orders: SortOrder[]
  }

  /**
   * 筛选配置项
   */
  export interface FilterConfig<D = VxeTablePropTypes.Row> {
    filterMethod?:(params: {
      $table: VxeTableConstructor<D>
      options: VxeTableDefines.FilterOption[]
      values: any[]
      cellValue: any
      row: D
      column: VxeTableDefines.ColumnInfo<D>
    }) => any
    /**
     * 是否精确筛选到每一行，默认情况下是父级被匹配到则所有子级也被匹配；如果传 true 则会对每一行进行筛选
     */
    isEvery?: boolean
    /**
     * 是否使用服务端筛选，如果设置为 true 则不会对数据进行处理
     */
    remote?: boolean
    /**
     * 是否允许多列筛选
     */
    multiple?: boolean
    /**
     * 是否显示筛选按钮图标
     */
    showIcon?: boolean
    /**
     * 只对 tree-config.transform 有效，是否允许同时筛选子孙层级
     */
    isDeep?: boolean
    /**
     * 筛选按钮图标的显示方法，该方法的返回值用于决定该列是否显示筛选按钮图标
     * @param params
     */
    iconVisibleMethod?(params: {
      $table: VxeTableConstructor<D>
      column: VxeTableDefines.ColumnInfo<D>
    }): boolean
    className?: string
    zIndex?: number
    transfer?: boolean
    iconNone?: string
    iconMatch?: string
    /**
     * 筛选面板最大高度
     */
    maxHeight?: number
    /**
     * 弹出层在关闭时是否销毁
     */
    destroyOnClose?: boolean
    /**
     * 自定义确认按钮内容
     */
    confirmButtonText?: string
    /**
     * 自定义重置按钮内容
     */
    resetButtonText?: string
    /**
     * 是否显示底部按钮
     */
    showFooter?: boolean
  }
  export interface FilterOpts<D = VxeTablePropTypes.Row> extends FilterConfig<D> { }

  export interface FloatingFilterConfig<D = VxeTablePropTypes.Row> {
    /**
     * 是否启用
     */
    enabled?: boolean
    /**
     * 是否启用浮动筛选
     */
    floatingFilters?: VxeColumnPropTypes.FloatingFilters
  }

  /**
   * 单选框配置
   */
  export interface RadioConfig<D = VxeTablePropTypes.Row> {
    reserve?: boolean
    labelField?: string
    checkRowKey?: string | number
    checkMethod?(params: {
      $table: VxeTableConstructor<D>
      row: D
    }): boolean
    visibleMethod?(params: {
      $table: VxeTableConstructor<D>
      row: D
    }): boolean
    trigger?: 'default' | 'cell' | 'row' | 'manual' | '' | null
    highlight?: boolean
    /**
     * 严格模式，选中后不能取消
     */
    strict?: boolean
  }
  export interface RadioOpts<D = VxeTablePropTypes.Row> extends RadioConfig<D> { }

  /**
   * 复选框配置项
   */
  export interface CheckboxConfig<D = VxeTablePropTypes.Row> {
    /**
     * 自定义列头复选框的 title 提示语
     */
    headerTitle?: string | number
    /**
     * 是否保留勾选状态，对于某些场景可能会用到，比如数据被刷新之后还保留之前选中的状态
     */
    reserve?: boolean
    /**
     * 是否显示保留勾选状态，启用后如果存在保留记录，则未勾选当前页数据也会显示未半选状态
     */
    showReserveStatus?: boolean
    /**
     * 复选框显示的字段名，可以直接显示在复选框中
     */
    labelField?: string
    /**
     * 绑定选中属性，支持读写，行数据中必须存在该字段，否则无效
     */
    checkField?: string
    /**
     * 绑定半选只读属性，仅有只读权限，不支持修改，行数据中必须存在该字段，否则无效
     */
    indeterminateField?: string
    /**
     * 是否显示全选按钮，如果 checkStrictly=true 则默认为 false
     */
    showHeader?: boolean
    /**
     * 默认勾选所有，只会在初始化时被触发一次
     */
    checkAll?: boolean
    /**
     * 默认勾选指定行，只会在初始化时被触发一次，需要有 row-config.keyField
     */
    checkRowKeys?: string[] | number[]
    /**
     * 是否严格的遵循父子不互相关联的做法
     */
    checkStrictly?: boolean
    /**
     * 严格模式，当数据为空或全部禁用时，列头的复选框为禁用状态
     */
    strict?: boolean
    /**
     * 开启复选框指定行选择功能，启用后通过鼠标点击和 shift 键选取指定范围的行
     */
    isShiftKey?: boolean
    /**
     * 是否允许勾选的方法，该方法，的返回值用来决定这一行的 checkbox 是否可以勾选
     */
    checkMethod?(params: {
      $table: VxeTableConstructor<D>
      row: D
    }): boolean
    /**
     * 是否允许勾选的方法，该方法，的返回值用来决定这一行的 checkbox 是否显示
     */
    visibleMethod?(params: {
      $table: VxeTableConstructor<D>
      row: D
    }): boolean
    /**
     * 触发方式
     */
    trigger?: 'default' | 'cell' | 'row' | 'manual' | '' | null
    /**
     * 是否高亮勾选行
     */
    highlight?: boolean
    /**
     * 开启复选框范围选择功能，启用后通过鼠标在复选框的列内滑动选中或取消指定行
     */
    range?: boolean

    /**
     * 请使用 indeterminateField
     * @deprecated
     */
    halfField?: string
  }
  export interface CheckboxOpts<D = VxeTablePropTypes.Row> extends CheckboxConfig<D> { }

  /**
   * 透视表配置项
   */
  // export interface PivotConfig<D = any> {

  // }

  /**
   * 提示信息配置项
   */
  export interface TooltipConfig<D = VxeTablePropTypes.Row> {
    showAll?: boolean
    theme?: VxeTooltipPropTypes.Theme
    enterable?: VxeTooltipPropTypes.Enterable
    enterDelay?: VxeTooltipPropTypes.EnterDelay
    leaveDelay?: VxeTooltipPropTypes.LeaveDelay
    width?: VxeTooltipPropTypes.Width
    height?: VxeTooltipPropTypes.Height
    minWidth?: VxeTooltipPropTypes.MinWidth
    minHeight?: VxeTooltipPropTypes.MinHeight
    maxWidth?: VxeTooltipPropTypes.MaxWidth
    maxHeight?: VxeTooltipPropTypes.MaxHeight
    useHTML?: VxeTooltipPropTypes.UseHTML
    placement?: VxeTooltipPropTypes.Placement
    defaultPlacement?: VxeTooltipPropTypes.DefaultPlacement
    popupClassName?: VxeTooltipPropTypes.PopupClassName
    contentMethod?(params: {
      $table: VxeTableConstructor<D>
      items: any[]
      row: D
      rowIndex: number
      $rowIndex: number
      _rowIndex: number
      column: VxeTableDefines.ColumnInfo<D>
      columnIndex: number
      $columnIndex: number
      _columnIndex: number
      type: 'body'
      cell: HTMLElement
      $event: any
    }): string | null | void
  }
  export interface HeaderTooltipConfig<D = VxeTablePropTypes.Row> extends Omit<TooltipConfig<D>, 'contentMethod'> {
    contentMethod?(params: {
      $table: VxeTableConstructor<D>
      $rowIndex: number
      column: VxeTableDefines.ColumnInfo<D>
      columnIndex: number
      $columnIndex: number
      _columnIndex: number
      type: 'header'
      cell: HTMLElement
      $event: any
    }): string | null | void
  }
  export interface FooterTooltipConfig<D = VxeTablePropTypes.Row> extends Omit<TooltipConfig<D>, 'contentMethod'> {
    contentMethod?(params: {
      $table: VxeTableConstructor<D>
      items: any[]
      row: D
      rowIndex: number
      $rowIndex: number
      column: VxeTableDefines.ColumnInfo<D>
      columnIndex: number
      $columnIndex: number
      _columnIndex: number
      type: 'footer'
      cell: HTMLElement
      $event: any
    }): string | null | void
  }

  /**
   * 展开行配置项
   */
  export interface ExpandConfig<D = any> {
    labelField?: string
    /**
     * 默认展开所有行（只会在初始化时被触发一次）
     */
    expandAll?: boolean
    /**
     * 默认展开指定行（只会在初始化时被触发一次，需要有 row-config.keyField）
     */
    expandRowKeys?: string[] | number[]
    accordion?: boolean
    trigger?: 'default' | 'cell' | 'row' | 'manual' |'' | null
    lazy?: boolean
    reserve?: boolean
    height?: number
    padding?: boolean
    /**
     * 展开内容的显示模式
     */
    mode?: 'inside' | 'fixed' | '' | null
    /**
     * 当存在树结构时，展开内容的缩进，默认继承树配置
     */
    indent?: number
    loadMethod?(params: {
      $table: VxeTableConstructor<D>
      row: D
      rowIndex: number
      $rowIndex: number
    }): Promise<void>
    toggleMethod?(params: {
      $table: VxeTableConstructor<D>
      expanded: boolean
      row: D
      rowIndex: number
      $rowIndex: number
      column: VxeTableDefines.ColumnInfo<D>
      columnIndex: number
      $columnIndex: number
    }): boolean
    visibleMethod?(params: VxeTableDefines.CellRenderBodyParams<D>): boolean
    showIcon?: boolean
    iconOpen?: string
    iconClose?: string
    iconLoaded?: string
  }
  export interface ExpandOpts<D = any> extends ExpandConfig<D> { }

  /**
   * 树形结构配置项
   */
  export interface TreeConfig<D = any> {
    /**
     * 自动将列表转为树结构
     */
    transform?: boolean
    /**
     * 用于 tree-config.transform，树节点的字段名
     */
    rowField?: string
    /**
     * 用于 tree-config.transform，树父节点的字段名
     */
    parentField?: string
    /**
     * 树子节点的字段名
     */
    childrenField?: string
    /**
     * 用于 tree-config.transform，树子节点映射的字段名
     */
    mapChildrenField?: string
    /**
     * 是否显示边距
     */
    padding?: boolean
    /**
     * 树节点的缩进
     */
    indent?: number
    /**
     * 树节点的连接线（启用连接线会降低渲染性能）
     */
    showLine?: boolean
    /**
     * 只对 showLine 有效，显示树的根节点连接线
     */
    showRootLine?: boolean
    /**
     * 树结构序号显示模式，支持层级序号和自增序号（仅支持 transform）个固定序号
     */
    seqMode?: 'default' | 'increasing' | 'fixed' | '' | null
    /**
     * 默认展开所有子孙树节点（只会在初始化时被触发一次）
     */
    expandAll?: boolean
    /**
     * 默认展开指定树节点（只会在初始化时被触发一次，需要有 row-config.keyField）
     */
    expandRowKeys?: string[] | number[]
    /**
     * 对于同一级的节点，每次只能展开一个
     */
    accordion?: boolean
    /**
     * 触发方式（注：当多种功能重叠时，会同时触发）
     */
    trigger?: 'default' | 'cell' | 'row' | 'manual' | '' | null
    /**
     * 是否使用懒加载（启用后只有指定 hasChildField 字段的节点才允许被点击）
     */
    lazy?: boolean
    /**
     * 只对 lazy 启用后有效，标识是否存在子节点，从而控制是否允许被点击
     */
    hasChildField?: string
    /**
     * 是否保留展开状态，对于某些场景可能会用到，比如数据被刷新之后还保留之前展开的状态（需要有 row-config.keyField）
     */
    reserve?: boolean
    /**
     * 该方法用于异步加载子节点
     */
    loadMethod?(params: {
      $table: VxeTableConstructor<D>
      row: D
    }): Promise<any[]>
    /**
     * 该方法在展开或关闭触发之前调用，可以通过返回值来决定是否允许继续执行
     */
    toggleMethod?(params: {
      $table: VxeTableConstructor<D>
      expanded: boolean
      row: D
      column: VxeTableDefines.ColumnInfo<D>
      columnIndex: number
      $columnIndex: number
    }): boolean
    /**
     * 是否显示图标按钮
     */
    showIcon?: boolean
    /**
     * 自定义展开后显示的图标
     */
    iconOpen?: string
    /**
     * 自定义收起后显示的图标
     */
    iconClose?: string
    /**
     * 自定义懒加载中显示的图标
     */
    iconLoaded?: string

    /**
     * 已废弃，请使用 showLine
     * @deprecated
     */
    line?: boolean
    /**
     * 已废弃，请使用 hasChildField
     * @deprecated
     */
    hasChild?: string
    /**
     * 已废弃，请使用 childrenField
     * @deprecated
     */
    children?: string
  }
  export type TreeOpts<D = any> = Required<TreeConfig<D>>

  /**
   * 快捷菜单配置项
   */
  export interface MenuConfig<D = any> {
    /**
     * 是否启用
     */
    enabled?: boolean
    /**
     * 表头的右键菜单
     */
    header?: VxeTableDefines.MenuOptions
    /**
     * 内容的右键菜单
     */
    body?: VxeTableDefines.MenuOptions
    /**
     * 表尾的右键菜单
     */
    footer?: VxeTableDefines.MenuOptions
    /**
     * 触发方式
     * default（默认右键表格触发）, cell（右键单元格触发）
     */
    trigger?: 'default' | 'cell' | '' | null
    /**
     * 菜单面板的 className
     */
    className?: string
    zIndex?: number
    transfer?: boolean
    destroyOnClose?: boolean
    /**
     * 该函数的返回值用来决定是否允许显示右键菜单（对于需要对菜单进行权限控制时可能会用到）
     */
    visibleMethod?(params: {
      $table: VxeTableConstructor<D>
      type: string
      options: VxeTableDefines.MenuFirstOption[][]
      columns: VxeTableDefines.ColumnInfo<D>[]
      row?: D
      rowIndex?: number
      column?: VxeTableDefines.ColumnInfo<D>
      columnIndex?: number
    }): boolean
  }
  export type MenuOpts<D = any> = Required<MenuConfig<D>>

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

  /**
   * 区域配置项
   */
  export interface AreaConfig<D = any> {
    /**
     * 是否显示操作提示消息
     */
    showActionMsg?: boolean
    /**
     * 自定义操作提示消息
     */
    customModalMsg?:(params: {
      $table: VxeTableConstructor<D>
      type: 'fnr' | 'clip' | 'merge' | 'selected'
      message: string
      status: VxeModalPropTypes.Status
    }) => void
    /**
     * 只对 mouse-config.area 启用后有效，启用多区域选取功能
     */
    multiple?: boolean
    /**
     * 用于指定哪些列允许被选取
     */
    includeFields?: string[]
    /**
     * 用于排除指定列允许不允许被选取
     */
    excludeFields?: string[]
    /**
     * 单元格选取的方法，返回是否允许被选取
     */
    selectedMethod?(params: {
      $table: VxeTableConstructor<D>
      row: D
      column: VxeTableDefines.ColumnInfo<D>
      $grid: VxeGridConstructor<D> | null | undefined
    }): boolean
    /**
     * 只对 mouse-config.area 启用后有效，表格头部选取功能
     */
    selectCellByHeader?: boolean
    /**
     * 只对 mouse-config.area 启用后有效，表格单元格选取功能
     */
    selectCellByBody?: boolean
    /**
     * 只对 mouse-config.area 启用后有效，点击单元格后自动选取当前行的单元格;如果为 true，当选中第一列时联动选择当前行的单元格
     */
    selectCellToRow?: boolean
    /**
     * 只对 mouse-config.area 启用后有效，选择单元格后显示列状态
     */
    showColumnStatus?: boolean
    /**
     * 只对 mouse-config.area 启用后有效，选择单元格后显示行状态
     */
    showRowStatus?: boolean
    /**
     * 只对 mouse-config.extension 启用后有效，将被选取区域的值复制到扩展区域中
     */
    extendByCopy?: boolean
    /**
     * 只对 mouse-config.extension 启用后有效，扩展区域时将自动识别数字规则进行计算
     */
    extendByCalc?: boolean
    /**
     * 只对 mouse-config.extension 启用后有效，扩展区域的方向控制
     */
    extendDirection?: boolean | {
      /**
       * 是否允许向上扩展
       */
      top?: boolean
      /**
       * 是否允许向下扩展
       */
      bottom?: boolean
      /**
       * 是否允许向左扩展
       */
      left?: boolean
      /**
       * 是否允许向右扩展
       */
      right?: boolean
    }
    /**
     * 只对 mouse-config.extension 启用后有效，扩展区域之前的方法，可以通过返回 false 阻止扩展行为
     * @param params
     */
    beforeExtendMethod?(params: VxeTableExtendCellAreaDefines.CellAreaExtensionStartParams<D>): boolean
    /**
     * 只对 mouse-config.extension 启用后有效，扩展区域之后的方法
     * @param params
     */
    afterExtendMethod?(params: VxeTableExtendCellAreaDefines.CellAreaExtensionEndParams<D>): void
    /**
     * 当点击表格之外，是否自动清除单元格的选取状态
     */
    autoClear?: boolean
    /**
     * 只对 extendByCalc 启用后有效，重写单元格扩展区域计算值的方法
     * @param params
     */
    extendCalcMethod?(params: VxeTableExtendCellAreaDefines.ExtendCellAreaCalcBaseParams<D>): any[][]
    /**
     * 只对 extendByCopy | extendByCalc 启用后有效，重写单元格扩展区域赋值的方法
     * @param params
     */
    extendSetMethod?(params: {
      $table: VxeTableConstructor<D>
      cellValue: any
      row: D
      column: VxeTableDefines.ColumnInfo<D>
    } & VxeTableExtendCellAreaDefines.ExtendCellAreaCalcBaseParams<D>): void
    /**
     * 只对 extendByCopy | extendByCalc 启用后有效，自定义单元格扩展区域赋值之前的方法，可以通过返回 false 阻止扩展赋值行为
     * @param params
     */
    beforeExtendSetMethod?(params: VxeTableExtendCellAreaDefines.ExtendCellAreaCalcBaseParams<D>): boolean
    /**
     * 只对 extendByCopy | extendByCalc 启用后有效，自定义单元格扩展区域赋值之后的方法
     * @param params
     */
    afterExtendSetMethod?(params: {
      $table: VxeTableConstructor<D>
      extendValues: any[][]
    } & VxeTableExtendCellAreaDefines.ExtendCellAreaCalcBaseParams<D>): void
  }
  export interface AreaOpts<D = any> extends AreaConfig<D> { }

  /**
   * 按键配置项
   */
  export interface KeyboardConfig<D = any> {
    /**
     * 是否启用全选
     */
    isAll?: boolean
    /**
     * 是否开启非编辑状态下，上下左右移动功能
     */
    isArrow?: boolean
    /**
     * 是否开启Esc键退出编辑功能
     */
    isEsc?: boolean
    /**
     * 是否开启删除键功能
     */
    isDel?: boolean
    /**
     * 是否开启回退键功能
     */
    isBack?: boolean
    /**
     * 是否开启回车移动上下行移动
     */
    isEnter?: boolean
    /**
     * 如果功能被支持，用于 mouse-config.area，开启同时按住方向键以活动区域为起始，向指定方向延伸单元格区域
     */
    isShift?: boolean
    /**
     * 是否开启TAB键左右移动功能
     */
    isTab?: boolean
    /**
     * 是否开启单元格选择编辑
     */
    isEdit?: boolean
    /**
     * 用于 mouse-config.area，开启合并和取消合并功能
     */
    isMerge?: boolean
    /**
     * 用于 mouse-config.area，开启复