0
# Core Table
1

2
The VxeTable component is the foundational table implementation providing comprehensive data display, interaction, and customization capabilities with high-performance virtual scrolling.
3

4
## Capabilities
5

6
### VxeTable Component
7

8
Core table component with virtual scrolling and extensive configuration options.
9

10
```typescript { .api }
11
/**
12
 * Core table component for data display and interaction
13
 */
14
interface VxeTable extends ComponentPublicInstance {
15
  // Basic configuration
16
  data: Record<string, any>[];
17
  height?: number | string;
18
  minHeight?: number | string;
19
  maxHeight?: number | string;
20
  stripe?: boolean;
21
  border?: boolean | string;
22
  round?: boolean;
23
  size?: VxeTablePropTypes.Size;
24
  fit?: boolean;
25
  loading?: boolean;
26
  align?: VxeTablePropTypes.Align;
27
  headerAlign?: VxeTablePropTypes.HeaderAlign;
28
  footerAlign?: VxeTablePropTypes.FooterAlign;
29
  showHeader?: boolean;
30
  showFooter?: boolean;
31
  
32
  // Display configuration
33
  showOverflow?: VxeTablePropTypes.ShowOverflow;
34
  showHeaderOverflow?: VxeTablePropTypes.ShowHeaderOverflow;
35
  showFooterOverflow?: VxeTablePropTypes.ShowFooterOverflow;
36
  emptyText?: string;
37
  emptyRender?: VxeTablePropTypes.EmptyRender;
38
  
39
  // Styling
40
  rowClassName?: VxeTablePropTypes.RowClassName;
41
  cellClassName?: VxeTablePropTypes.CellClassName;
42
  headerRowClassName?: VxeTablePropTypes.HeaderRowClassName;
43
  headerCellClassName?: VxeTablePropTypes.HeaderCellClassName;
44
  footerRowClassName?: VxeTablePropTypes.FooterRowClassName;
45
  footerCellClassName?: VxeTablePropTypes.FooterCellClassName;
46
  rowStyle?: VxeTablePropTypes.RowStyle;
47
  cellStyle?: VxeTablePropTypes.CellStyle;
48
  headerRowStyle?: VxeTablePropTypes.HeaderRowStyle;
49
  headerCellStyle?: VxeTablePropTypes.HeaderCellStyle;
50
  footerRowStyle?: VxeTablePropTypes.FooterRowStyle;
51
  footerCellStyle?: VxeTablePropTypes.FooterCellStyle;
52
  
53
  // Advanced configuration objects
54
  rowConfig?: VxeTablePropTypes.RowConfig;
55
  columnConfig?: VxeTablePropTypes.ColumnConfig;
56
  resizableConfig?: VxeTablePropTypes.ResizableConfig;
57
  sortConfig?: VxeTablePropTypes.SortConfig;
58
  filterConfig?: VxeTablePropTypes.FilterConfig;
59
  radioConfig?: VxeTablePropTypes.RadioConfig;
60
  checkboxConfig?: VxeTablePropTypes.CheckboxConfig;
61
  tooltipConfig?: VxeTablePropTypes.TooltipConfig;
62
  editConfig?: VxeTablePropTypes.EditConfig;
63
  validConfig?: VxeTablePropTypes.ValidConfig;
64
  editRules?: VxeTablePropTypes.EditRules;
65
  expandConfig?: VxeTablePropTypes.ExpandConfig;
66
  treeConfig?: VxeTablePropTypes.TreeConfig;
67
  menuConfig?: VxeTablePropTypes.MenuConfig;
68
  mouseConfig?: VxeTablePropTypes.MouseConfig;
69
  areaConfig?: VxeTablePropTypes.AreaConfig;
70
  keyboardConfig?: VxeTablePropTypes.KeyboardConfig;
71
  clipConfig?: VxeTablePropTypes.ClipConfig;
72
  fnrConfig?: VxeTablePropTypes.FnrConfig;
73
  
74
  // Virtual scrolling
75
  virtualXConfig?: VxeTablePropTypes.VirtualXConfig;
76
  virtualYConfig?: VxeTablePropTypes.VirtualYConfig;
77
  scrollbarConfig?: VxeTablePropTypes.ScrollbarConfig;
78
  
79
  // Data management
80
  footerData?: Record<string, any>[][];
81
  keepSource?: boolean;
82
  autoResize?: boolean;
83
  syncResize?: boolean;
84
  
85
  // Component methods
86
  loadData(data: Record<string, any>[]): Promise<void>;
87
  reloadData(data: Record<string, any>[]): Promise<void>;
88
  updateData(): Promise<void>;
89
  createData(records: Record<string, any>[]): Promise<void>;
90
  createRow(records: Record<string, any> | Record<string, any>[]): Promise<void>;
91
  revertData(rows?: any | any[], field?: string): Promise<void>;
92
  clearAll(): Promise<void>;
93
  syncData(): Promise<void>;
94
  getTableData(): {
95
    visibleData: Record<string, any>[];
96
    fullData: Record<string, any>[];
97
    tableData: Record<string, any>[];
98
  };
99
  clearData(): Promise<void>;
100
  
101
  // Row operations
102
  getRowNode(tr: HTMLElement): VxeTableDefines.RowInfo | null;
103
  getRowById(rowid: string | number): any;
104
  getRowid(row: any): string;
105
  getRowIndex(row: any): number;
106
  getVTRowIndex(row: any): number;
107
  getVMRowIndex(row: any): number;
108
  setRow(row: any, record: Record<string, any>): Promise<void>;
109
  moveRowTo(rows: any | any[], targetRow: any): Promise<void>;
110
  getCurrentRecord(): any;
111
  setCurrentRow(row: any): Promise<void>;
112
  clearCurrentRow(): Promise<void>;
113
  
114
  // Column operations
115
  getColumnById(colid: string): VxeTableDefines.ColumnInfo;
116
  getColumnByField(field: string): VxeTableDefines.ColumnInfo;
117
  getColumns(): VxeTableDefines.ColumnInfo[];
118
  getVisibleColumns(): VxeTableDefines.ColumnInfo[];
119
  loadColumn(columns: VxeColumnDefines.ColumnOptions[]): Promise<void>;
120
  reloadColumn(columns: VxeColumnDefines.ColumnOptions[]): Promise<void>;
121
  setColumnFixed(fieldOrColumn: string | VxeTableDefines.ColumnInfo, fixed: VxeColumnPropTypes.Fixed): Promise<void>;
122
  setColumnWidth(fieldOrColumn: string | VxeTableDefines.ColumnInfo, width: number | string): Promise<void>;
123
  hideColumn(fieldOrColumn: string | VxeTableDefines.ColumnInfo): Promise<void>;
124
  showColumn(fieldOrColumn: string | VxeTableDefines.ColumnInfo): Promise<void>;
125
  refreshColumn(): Promise<void>;
126
  getCurrentColumn(): VxeTableDefines.ColumnInfo;
127
  setCurrentColumn(fieldOrColumn: string | VxeTableDefines.ColumnInfo): Promise<void>;
128
  clearCurrentColumn(): Promise<void>;
129
  
130
  // Selection operations
131
  getRadioRecord(): any;
132
  setRadioRow(row: any): Promise<void>;
133
  clearRadioRow(): Promise<void>;
134
  isCheckedByRadioRow(row: any): boolean;
135
  getCheckboxRecords(): Record<string, any>[];
136
  setCheckboxRow(rows: Record<string, any>[], checked: boolean): Promise<void>;
137
  toggleCheckboxRow(row: any): Promise<void>;
138
  setAllCheckboxRow(checked: boolean): Promise<void>;
139
  clearCheckboxRow(): Promise<void>;
140
  isCheckedByCheckboxRow(row: any): boolean;
141
  
142
  // Sorting
143
  sort(sortConfs: VxeTableDefines.SortCheckedParams[]): Promise<void>;
144
  clearSort(): Promise<void>;
145
  getSortColumns(): VxeTableDefines.SortCheckedParams[];
146
  
147
  // Filtering
148
  filter(filters: VxeTableDefines.FilterCheckedParams[]): Promise<void>;
149
  clearFilter(fieldOrColumn?: string | VxeTableDefines.ColumnInfo): Promise<void>;
150
  closeFilter(): Promise<void>;
151
  clearFilterByEvent(): Promise<void>;
152
  isActiveFilterByColumn(fieldOrColumn: string | VxeTableDefines.ColumnInfo): boolean;
153
  
154
  // Cell operations
155
  getCellElement(row: any, fieldOrColumn: string | VxeTableDefines.ColumnInfo): HTMLElement;
156
  focus(): Promise<void>;
157
  blur(): Promise<void>;
158
  
159
  // Export/Import
160
  exportData(options?: VxeTablePropTypes.ExportConfig): Promise<void>;
161
  openImport(options?: VxeTablePropTypes.ImportConfig): Promise<void>;
162
  
163
  // Tree operations
164
  setTreeExpand(rows: any[], expanded: boolean): Promise<void>;
165
  setAllTreeExpand(expanded: boolean): Promise<void>;
166
  toggleTreeExpand(row: any): Promise<void>;
167
  clearTreeExpand(): Promise<void>;
168
  isTreeExpandByRow(row: any): boolean;
169
  getTreeExpandRecords(): any[];
170
  loadTreeChildren(row: any, childRecords: any[]): Promise<void>;
171
  
172
  // Row expansion
173
  setRowExpand(rows: any[], expanded: boolean): Promise<void>;
174
  setAllRowExpand(expanded: boolean): Promise<void>;
175
  toggleRowExpand(row: any): Promise<void>;
176
  clearRowExpand(): Promise<void>;
177
  isRowExpandByRow(row: any): boolean;
178
  getRowExpandRecords(): any[];
179
  
180
  // Scrolling operations
181
  getScroll(): VxeTableDefines.ScrollInfo;
182
  scrollTo(scrollLeft: number, scrollTop?: number): Promise<void>;
183
  scrollToRow(row: any, fieldOrColumn?: string | VxeTableDefines.ColumnInfo): Promise<void>;
184
  scrollToColumn(fieldOrColumn: string | VxeTableDefines.ColumnInfo): Promise<void>;
185
  clearScroll(): Promise<void>;
186
  
187
  // Cell merging
188
  setMergeCells(merges: VxeTableDefines.MergeOptions[]): Promise<void>;
189
  removeMergeCells(merges: VxeTableDefines.MergeOptions[]): Promise<void>;
190
  getMergeCells(): VxeTableDefines.MergeInfo[];
191
  clearMergeCells(): Promise<void>;
192
  
193
  // Layout and sizing
194
  recalculate(): Promise<void>;
195
  refreshScroll(): Promise<void>;
196
  updateFooter(): Promise<void>;
197
  setRowHeight(rows: any[], height: number | string): Promise<void>;
198
  
199
  // Toolbar integration
200
  connectToolbar($toolbar: VxeToolbarInstance): Promise<void>;
201
}
202
```
203

204
### Basic Table Props
205

206
Essential properties for table setup and data display.
207

208
```typescript { .api }
209
interface BasicTableProps {
210
  /** Table data array */
211
  data?: Record<string, any>[];
212
  /** Table height (number for pixels, string for CSS values) */
213
  height?: number | string;
214
  /** Minimum table height */
215
  minHeight?: number | string;
216
  /** Maximum table height */
217
  maxHeight?: number | string;
218
  /** Enable row striping */
219
  stripe?: boolean;
220
  /** Border style ('default' | 'full' | 'outer' | 'inner' | 'none') */
221
  border?: boolean | string;
222
  /** Round corners */
223
  round?: boolean;
224
  /** Component size */
225
  size?: 'mini' | 'small' | 'medium' | 'large';
226
  /** Auto fit container width */
227
  fit?: boolean;
228
  /** Loading state */
229
  loading?: boolean;
230
  /** Cell content alignment */
231
  align?: 'left' | 'center' | 'right';
232
  /** Header alignment */
233
  headerAlign?: 'left' | 'center' | 'right';
234
  /** Footer alignment */
235
  footerAlign?: 'left' | 'center' | 'right';
236
  /** Show table header */
237
  showHeader?: boolean;
238
  /** Show table footer */
239
  showFooter?: boolean;
240
}
241
```
242

243
### Virtual Scrolling Configuration
244

245
High-performance virtual scrolling for large datasets.
246

247
```typescript { .api }
248
interface VirtualScrollConfig {
249
  /** Horizontal virtual scrolling configuration */
250
  virtualXConfig?: {
251
    /** Enable horizontal virtual scrolling */
252
    enabled?: boolean;
253
    /** Threshold to trigger virtual scrolling */
254
    gt?: number;
255
    /** Pre-render size */
256
    preSize?: number;
257
    /** Buffer size */
258
    oSize?: number;
259
  };
260
  
261
  /** Vertical virtual scrolling configuration */
262
  virtualYConfig?: {
263
    /** Enable vertical virtual scrolling */
264
    enabled?: boolean;
265
    /** Scroll mode ('wheel' | 'native') */
266
    mode?: string;
267
    /** Threshold to trigger virtual scrolling */
268
    gt?: number;
269
    /** Pre-render size */
270
    preSize?: number;
271
    /** Buffer size */
272
    oSize?: number;
273
  };
274
  
275
  /** Scrollbar configuration */
276
  scrollbarConfig?: {
277
    /** Horizontal scrollbar */
278
    x?: {
279
      /** Position ('top' | 'bottom') */
280
      position?: string;
281
      /** Visibility */
282
      visible?: boolean;
283
    };
284
    /** Vertical scrollbar */
285
    y?: {
286
      /** Position ('left' | 'right') */
287
      position?: string;
288
      /** Visibility */
289
      visible?: boolean;
290
    };
291
  };
292
}
293
```
294

295
### Row and Column Configuration
296

297
Advanced row and column behavior configuration.
298

299
```typescript { .api }
300
interface RowColumnConfig {
301
  /** Row configuration */
302
  rowConfig?: {
303
    /** Row key field for tracking */
304
    keyField?: string;
305
    /** Use key for performance optimization */
306
    useKey?: boolean;
307
    /** Resizable rows */
308
    resizable?: boolean;
309
    /** Row height */
310
    height?: number | string;
311
  };
312
  
313
  /** Column configuration */
314
  columnConfig?: {
315
    /** Resizable columns */
316
    resizable?: boolean;
317
    /** Use key for performance optimization */
318
    useKey?: boolean;
319
    /** Width calculation mode */
320
    width?: 'auto' | number;
321
    /** Minimum column width */
322
    minWidth?: number;
323
    /** Maximum fixed columns */
324
    maxFixedSize?: number;
325
  };
326
  
327
  /** Column resizing configuration */
328
  resizableConfig?: {
329
    /** Drag mode ('auto' | 'manual') */
330
    dragMode?: string;
331
    /** Show drag tip */
332
    showDragTip?: boolean;
333
    /** Sync auto height */
334
    isSyncAutoHeight?: boolean;
335
    /** Sync auto width */
336
    isSyncAutoWidth?: boolean;
337
    /** Minimum height */
338
    minHeight?: number;
339
  };
340
}
341
```
342

343
**Usage Examples:**
344

345
```typescript
346
// Basic table setup
347
<VxeTable
348
  :data="tableData"
349
  border
350
  stripe
351
  height="400"
352
  :virtual-y-config="{ enabled: true, gt: 100 }"
353
>
354
  <VxeColumn field="id" title="ID" width="80"></VxeColumn>
355
  <VxeColumn field="name" title="Name" min-width="120"></VxeColumn>
356
  <VxeColumn field="age" title="Age" width="80"></VxeColumn>
357
</VxeTable>
358

359
// Virtual scrolling for large datasets
360
<VxeTable
361
  :data="largeDataset"
362
  :virtual-x-config="{ enabled: true, gt: 20 }"
363
  :virtual-y-config="{ enabled: true, gt: 100 }"
364
  :scroll-y="{ enabled: true, gt: 100 }"
365
  height="600"
366
>
367
  <!-- columns -->
368
</VxeTable>
369

370
// Programmatic API usage
371
const tableRef = ref<VxeTableInstance>();
372

373
// Load data
374
await tableRef.value?.loadData(newData);
375

376
// Get current selection
377
const currentRow = tableRef.value?.getCurrentRecord();
378

379
// Scroll to specific row
380
await tableRef.value?.scrollToRow(targetRow);
381
```
382

383
### Table Events
384

385
VxeTable provides comprehensive event coverage for all user interactions and data operations.
386

387
```typescript { .api }
388
interface VxeTableEvents {
389
  // Data events
390
  'update:data': (data: any[]) => void;
391
  'data-change': (params: VxeTableDefines.DataChangeEventParams) => void;
392
  'footer-data-change': (params: VxeTableDefines.FooterDataChangeEventParams) => void;
393
  
394
  // Cell events
395
  'cell-click': (params: VxeTableDefines.CellClickEventParams) => void;
396
  'cell-dblclick': (params: VxeTableDefines.CellDblclickEventParams) => void;
397
  'cell-menu': (params: VxeTableDefines.CellMenuEventParams) => void;
398
  'cell-mouseenter': (params: VxeTableDefines.CellMouseenterEventParams) => void;
399
  'cell-mouseleave': (params: VxeTableDefines.CellMouseleaveEventParams) => void;
400
  
401
  // Header events
402
  'header-cell-click': (params: VxeTableDefines.HeaderCellClickEventParams) => void;
403
  'header-cell-dblclick': (params: VxeTableDefines.HeaderCellDblclickEventParams) => void;
404
  'header-cell-menu': (params: VxeTableDefines.HeaderCellMenuEventParams) => void;
405
  
406
  // Footer events
407
  'footer-cell-click': (params: VxeTableDefines.FooterCellClickEventParams) => void;
408
  'footer-cell-dblclick': (params: VxeTableDefines.FooterCellDblclickEventParams) => void;
409
  'footer-cell-menu': (params: VxeTableDefines.FooterCellMenuEventParams) => void;
410
  
411
  // Row selection events
412
  'current-row-change': (params: VxeTableDefines.CurrentRowChangeEventParams) => void;
413
  'current-column-change': (params: VxeTableDefines.CurrentColumnChangeEventParams) => void;
414
  'radio-change': (params: VxeTableDefines.RadioChangeEventParams) => void;
415
  'checkbox-change': (params: VxeTableDefines.CheckboxChangeEventParams) => void;
416
  'checkbox-all': (params: VxeTableDefines.CheckboxAllEventParams) => void;
417
  'checkbox-range-start': (params: VxeTableDefines.CheckboxRangeStartEventParams) => void;
418
  'checkbox-range-change': (params: VxeTableDefines.CheckboxRangeChangeEventParams) => void;
419
  'checkbox-range-end': (params: VxeTableDefines.CheckboxRangeEndEventParams) => void;
420
  
421
  // Edit events
422
  'edit-activated': (params: VxeTableDefines.EditActivatedEventParams) => void;
423
  'edit-disabled': (params: VxeTableDefines.EditDisabledEventParams) => void;
424
  'edit-closed': (params: VxeTableDefines.EditClosedEventParams) => void;
425
  'valid-error': (params: VxeTableDefines.ValidErrorEventParams) => void;
426
  
427
  // Sort and filter events
428
  'sort-change': (params: VxeTableDefines.SortChangeEventParams) => void;
429
  'clear-sort': (params: VxeTableDefines.ClearSortEventParams) => void;
430
  'filter-change': (params: VxeTableDefines.FilterChangeEventParams) => void;
431
  'clear-filter': (params: VxeTableDefines.ClearFilterEventParams) => void;
432
  
433
  // Tree structure events
434
  'toggle-tree-expand': (params: VxeTableDefines.ToggleTreeExpandEventParams) => void;
435
  'toggle-row-expand': (params: VxeTableDefines.ToggleRowExpandEventParams) => void;
436
  
437
  // Scroll events
438
  'scroll': (params: VxeTableDefines.ScrollEventParams) => void;
439
  'scroll-start': (params: VxeTableDefines.ScrollStartEventParams) => void;
440
  'scroll-end': (params: VxeTableDefines.ScrollEndEventParams) => void;
441
  'scroll-boundary': (params: VxeTableDefines.ScrollBoundaryEventParams) => void;
442
  
443
  // Area selection and clipboard events
444
  'cell-area-selection-start': (params: VxeTableDefines.CellAreaSelectionStartEventParams) => void;
445
  'cell-area-selection-drag': (params: VxeTableDefines.CellAreaSelectionDragEventParams) => void;
446
  'cell-area-selection-end': (params: VxeTableDefines.CellAreaSelectionEndEventParams) => void;
447
  'cell-area-copy': (params: VxeTableDefines.CellAreaCopyEventParams) => void;
448
  'cell-area-cut': (params: VxeTableDefines.CellAreaCutEventParams) => void;
449
  'cell-area-paste': (params: VxeTableDefines.CellAreaPasteEventParams) => void;
450
  
451
  // Drag and drop events
452
  'row-dragstart': (params: VxeTableDefines.RowDragstartEventParams) => void;
453
  'row-dragover': (params: VxeTableDefines.RowDragoverEventParams) => void;
454
  'row-dragend': (params: VxeTableDefines.RowDragendEventParams) => void;
455
  'column-dragstart': (params: VxeTableDefines.ColumnDragstartEventParams) => void;
456
  'column-dragover': (params: VxeTableDefines.ColumnDragoverEventParams) => void;
457
  'column-dragend': (params: VxeTableDefines.ColumnDragendEventParams) => void;
458
  
459
  // Keyboard events
460
  'keydown-start': (params: VxeTableDefines.KeydownStartEventParams) => void;
461
  'keydown': (params: VxeTableDefines.KeydownEventParams) => void;
462
  'keydown-end': (params: VxeTableDefines.KeydownEndEventParams) => void;
463
  
464
  // Context menu events
465
  'menu-click': (params: VxeTableDefines.MenuClickEventParams) => void;
466
  
467
  // Resize events
468
  'column-resizable': (params: VxeTableDefines.ColumnResizableEventParams) => void;
469
  'column-resizable-change': (params: VxeTableDefines.ColumnResizableChangeEventParams) => void;
470
}
471
```
472

473
## Types
474

475
```typescript { .api }
476
// Table size options
477
type VxeTablePropTypes.Size = 'mini' | 'small' | 'medium' | 'large';
478

479
// Alignment options
480
type VxeTablePropTypes.Align = 'left' | 'center' | 'right';
481

482
// Overflow display options
483
type VxeTablePropTypes.ShowOverflow = boolean | 'ellipsis' | 'title' | 'tooltip';
484

485
// Row/cell styling function types
486
type VxeTablePropTypes.RowClassName = string | ((params: any) => string);
487
type VxeTablePropTypes.CellClassName = string | ((params: any) => string);
488
type VxeTablePropTypes.RowStyle = object | ((params: any) => object);
489
type VxeTablePropTypes.CellStyle = object | ((params: any) => object);
490

491
// Row and scroll information types
492
interface VxeTableDefines.RowInfo {
493
  $seq: number;
494
  seq: number;
495
  rowIndex: number;
496
  $rowIndex: number;
497
  _rowIndex: number;
498
  index: number;
499
  $index: number;
500
  _index: number;
501
  row: any;
502
  rowKey: string | number;
503
  level: number;
504
  parent: any;
505
  children?: any[];
506
  height: number;
507
  top: number;
508
  [key: string]: any;
509
}
510

511
interface VxeTableDefines.ScrollInfo {
512
  virtualX: boolean;
513
  virtualY: boolean;
514
  scrollTop: number;
515
  scrollLeft: number;
516
  bodyWidth: number;
517
  bodyHeight: number;
518
  isScrollX: boolean;
519
  isScrollY: boolean;
520
}
521

522
// Merge operation types
523
interface VxeTableDefines.MergeOptions {
524
  row: any;
525
  column: VxeColumnDefines.ColumnInfo;
526
  rowspan?: number;
527
  colspan?: number;
528
}
529

530
interface VxeTableDefines.MergeInfo {
531
  row: any;
532
  column: VxeColumnDefines.ColumnInfo;
533
  rowspan: number;
534
  colspan: number;
535
}
536

537
// Sort and filter parameter types
538
interface VxeTableDefines.SortCheckedParams {
539
  column: VxeColumnDefines.ColumnInfo;
540
  field: string;
541
  order: 'asc' | 'desc' | null;
542
}
543

544
interface VxeTableDefines.FilterCheckedParams {
545
  column: VxeColumnDefines.ColumnInfo;
546
  field: string;
547
  values: any[];
548
  datas: any[];
549
}
550

551
// Column options for dynamic columns
552
interface VxeColumnDefines.ColumnOptions {
553
  field?: string;
554
  title?: string;
555
  width?: number | string;
556
  minWidth?: number | string;
557
  maxWidth?: number | string;
558
  type?: VxeColumnPropTypes.Type;
559
  fixed?: VxeColumnPropTypes.Fixed;
560
  align?: VxeColumnPropTypes.Align;
561
  headerAlign?: VxeColumnPropTypes.HeaderAlign;
562
  showOverflow?: VxeColumnPropTypes.ShowOverflow;
563
  [key: string]: any;
564
}
565

566
// Event parameter types
567
interface VxeTableDefines.DataChangeEventParams {
568
  type: string;
569
  $event: Event;
570
}
571

572
interface VxeTableDefines.CellClickEventParams {
573
  row: any;
574
  rowIndex: number;
575
  column: VxeColumnDefines.ColumnInfo;
576
  columnIndex: number;
577
  cell: HTMLElement;
578
  triggerRadio: boolean;
579
  triggerCheckbox: boolean;
580
  triggerTreeNode: boolean;
581
  triggerExpandNode: boolean;
582
  $event: MouseEvent;
583
}
584

585
interface VxeTableDefines.CurrentRowChangeEventParams {
586
  row: any;
587
  rowIndex: number;
588
  $event: Event;
589
}
590

591
interface VxeTableDefines.RadioChangeEventParams {
592
  row: any;
593
  rowIndex: number;
594
  $event: Event;
595
}
596

597
interface VxeTableDefines.CheckboxChangeEventParams {
598
  records: any[];
599
  reserves: any[];
600
  indeterminates: any[];
601
  checked: boolean;
602
  $event: Event;
603
}
604

605
interface VxeTableDefines.EditActivatedEventParams {
606
  row: any;
607
  rowIndex: number;
608
  column: VxeColumnDefines.ColumnInfo;
609
  columnIndex: number;
610
  cell: HTMLElement;
611
  $event: Event;
612
}
613

614
interface VxeTableDefines.ValidErrorEventParams {
615
  row: any;
616
  column: VxeColumnDefines.ColumnInfo;
617
  cell: HTMLElement;
618
  rule: any;
619
  rules: any[];
620
  $event: Event;
621
}
622

623
interface VxeTableDefines.SortChangeEventParams {
624
  column: VxeColumnDefines.ColumnInfo;
625
  field: string;
626
  property: string;
627
  order: 'asc' | 'desc' | null;
628
  sortBy: string;
629
  sortTime: number;
630
  $event: Event;
631
}
632

633
interface VxeTableDefines.FilterChangeEventParams {
634
  column: VxeColumnDefines.ColumnInfo;
635
  field: string;
636
  property: string;
637
  values: any[];
638
  datas: any[];
639
  filters: any[];
640
  filterTime: number;
641
  $event: Event;
642
}
643

644
interface VxeTableDefines.ScrollEventParams {
645
  type: string;
646
  fixed: VxeColumnPropTypes.Fixed;
647
  scrollTop: number;
648
  scrollLeft: number;
649
  isX: boolean;
650
  isY: boolean;
651
  $event: Event;
652
}
653

654
interface VxeTableDefines.ToggleTreeExpandEventParams {
655
  row: any;
656
  rowIndex: number;
657
  column: VxeColumnDefines.ColumnInfo;
658
  columnIndex: number;
659
  $event: Event;
660
}
661

662
interface VxeTableDefines.MenuClickEventParams {
663
  menu: any;
664
  type: string;
665
  row?: any;
666
  rowIndex?: number;
667
  column?: VxeColumnDefines.ColumnInfo;
668
  columnIndex?: number;
669
  $event: Event;
670
}
671

672
// Table instance type
673
interface VxeTableInstance extends ComponentPublicInstance, VxeTable {}
674
```