primereact 8.7.3 → 9.0.0-beta.1

package/datatable/datatable.d.ts

@@ -1,389 +1,1417 @@
+/**
+ *
+ * DataTable displays data in tabular format.
+ *
+ * [Live Demo](https://www.primefaces.org/primereact/datatable/)
+ *
+ * @module datatable
+ *
+ */
 import * as React from 'react';
-import { Column, ColumnFilterMatchModeType } from '../column';
+import { Column, ColumnProps } from '../column';
 import { PaginatorTemplate } from '../paginator';
 import { VirtualScroller, VirtualScrollerProps } from '../virtualscroller/virtualscroller';
 
-type DataTableHeaderTemplateType = React.ReactNode | ((options: DataTableHeaderTemplateOptions) => React.ReactNode);
+type DataTableHeaderTemplateType<TValue extends DataTableValueArray> = React.ReactNode | ((options: DataTableHeaderTemplateOptions<TValue>) => React.ReactNode);
 
-type DataTableFooterTemplateType = React.ReactNode | ((options: DataTableFooterTemplateOptions) => React.ReactNode);
+type DataTableFooterTemplateType<TValue extends DataTableValueArray> = React.ReactNode | ((options: DataTableFooterTemplateOptions<TValue>) => React.ReactNode);
 
-type DataTableRowGroupHeaderTemplateType = React.ReactNode | ((data: any, options: DataTableRowGroupHeaderTemplateOptions) => React.ReactNode);
+type DataTableRowGroupHeaderTemplateType<TValue extends DataTableValueArray> = React.ReactNode | ((data: any, options: DataTableRowGroupHeaderTemplateOptions<TValue>) => React.ReactNode);
 
-type DataTableRowGroupFooterTemplateType = React.ReactNode | ((data: any, options: DataTableRowGroupFooterTemplateOptions) => React.ReactNode);
+type DataTableRowGroupFooterTemplateType<TValue extends DataTableValueArray> = React.ReactNode | ((data: any, options: DataTableRowGroupFooterTemplateOptions<TValue>) => React.ReactNode);
 
-type DataTablePaginatorPositionType = 'top' | 'bottom' | 'both';
-
-type DataTableSortModeType = 'single' | 'multiple';
-
-type DataTableSortOrderType = 1 | 0 | -1 | undefined | null;
-
-type DataTableEmptyMessageType = React.ReactNode | ((frozen: boolean) => React.ReactNode);
-
-type DataTableSelectionModeType = 'single' | 'multiple' | 'checkbox' | 'radiobutton';
-
-type DataTableColumnResizeModeType = 'fit' | 'expand';
-
-type DataTableFilterMatchModeType = 'startsWith' | 'contains' | 'notContains' | 'endsWith' | 'equals' | 'notEquals' | 'in' | 'lt' | 'lte' | 'gt' | 'gte' | 'between' | 'dateIs' | 'dateIsNot' | 'dateBefore' | 'dateAfter' | 'custom';
-
-type DataTableGlobalFilterType = string | undefined | null;
-
-type DataTableMultiSortMetaType = DataTableSortMeta[] | undefined | null;
-
-type DataTableCompareSelectionByType = 'deepEquals' | 'equals';
-
-type DataTableStateStorageType = 'session' | 'local' | 'custom';
-
-type DataTableAppendToType = 'self' | HTMLElement | undefined | null;
-
-type DataTableSelectType = 'row' | 'cell' | 'checkbox' | 'radio' | 'all';
-
-type DataTableResponsiveLayoutType = 'scroll' | 'stack';
-
-type DataTableFilterDisplayType = 'menu' | 'row';
-
-type DataTableSizeType = 'small' | 'normal' | 'large';
-
-type DataTableScrollDirectionType = 'vertical' | 'horizontal' | 'both';
-
-interface DataTableHeaderTemplateOptions {
-    props: DataTableProps;
+/**
+ * Custom datatable header template options.
+ * @group Misc
+ */
+interface DataTableHeaderTemplateOptions<TValue extends DataTableValueArray> {
+    /**
+     * The props of the datatable.
+     */
+    props: DataTableProps<TValue>;
 }
 
-interface DataTableFooterTemplateOptions extends DataTableHeaderTemplateOptions {}
+interface DataTableFooterTemplateOptions<TValue extends DataTableValueArray> extends DataTableHeaderTemplateOptions<TValue> {}
 
-interface DataTableRowGroupHeaderTemplateOptions {
+/**
+ * Custom datatable row group header template options.
+ * @group Misc
+ */
+interface DataTableRowGroupHeaderTemplateOptions<TValue extends DataTableValueArray> {
+    /**
+     * index of the row group header template.
+     */
     index: number;
-    props: DataTableProps;
+    /**
+     * The props of the datatable.
+     */
+    props: DataTableProps<TValue>;
+    /**
+     * Used to override the rendering of the content.
+     */
     customRendering: boolean;
 }
 
-interface DataTableRowGroupFooterTemplateOptions extends DataTableRowGroupHeaderTemplateOptions {
+/**
+ * Custom datatable row group footer template options.
+ * @group Misc
+ */
+interface DataTableRowGroupFooterTemplateOptions<T extends DataTableValueArray> extends DataTableRowGroupHeaderTemplateOptions<T> {
+    /**
+     * Number of columns to span for grouping.
+     */
     colSpan: number;
 }
 
+/**
+ * Custom datatable sort meta
+ * @group Misc
+ */
 interface DataTableSortMeta {
+    /**
+     * Column field to sort against.
+     */
     field: string;
-    order: DataTableSortOrderType;
+    /**
+     * Sort order as integer.
+     */
+    order: 1 | 0 | -1 | null | undefined;
 }
 
+/**
+ * Custom datatable filter metadata.
+ * @group Misc
+ */
 interface DataTableFilterMetaData {
+    /**
+     * Value to filter against.
+     */
     value: any;
-    matchMode: DataTableFilterMatchModeType;
+    /**
+     * Type of filter match.
+     */
+    matchMode: 'startsWith' | 'contains' | 'notContains' | 'endsWith' | 'equals' | 'notEquals' | 'in' | 'lt' | 'lte' | 'gt' | 'gte' | 'between' | 'dateIs' | 'dateIsNot' | 'dateBefore' | 'dateAfter' | 'custom' | undefined;
 }
 
+/**
+ * Custom datatable operator filter metadata.
+ * @group Misc
+ */
 interface DataTableOperatorFilterMetaData {
+    /**
+     * Operator to use for filtering.
+     */
     operator: string;
+    /**
+     * Operator to use for filtering.
+     */
     constraints: DataTableFilterMetaData[];
 }
 
+/**
+ * Custom datatable filter meta.
+ * @group Misc
+ */
 interface DataTableFilterMeta {
+    /**
+     * Extra options.
+     */
     [key: string]: DataTableFilterMetaData | DataTableOperatorFilterMetaData;
 }
 
+/**
+ * Custom datatable expanded rows.
+ * @group Misc
+ */
 interface DataTableExpandedRows {
     [key: string]: boolean;
 }
 
+/**
+ * Custom datatable editing rows.
+ * @group Misc
+ */
 interface DataTableEditingRows {
     [key: string]: boolean;
 }
 
-interface DataTableRowToggleParams {
+/**
+ * Custom row toggle event.
+ * @see {@link DataTableProps.onRowToggle}
+ * @event
+ */
+interface DataTableRowToggleEvent {
+    /**
+     * Expanded rows.
+     */
     data: any[] | DataTableExpandedRows;
 }
 
-interface DataTableColumnResizeEndParams {
+/**
+ * Custom resize end event.
+ * @see {@link DataTableProps.onColumnResizeEnd}
+ * @event
+ */
+interface DataTableColumnResizeEndEvent {
+    /**
+     * DOM element of the resized column.
+     */
     element: HTMLElement;
+    /**
+     * Properties of the resized column.
+     */
     column: Column;
+    /**
+     * Change in column width.
+     */
     delta: number;
 }
 
-interface DataTableColumnResizerClickParams {
+/**
+ * Custom column resizer click event.
+ * @see {@link DataTableProps.onColumnResizerClick}, {@link DataTableProps.onColumnResizerDoubleClick}
+ * @event
+ */
+interface DataTableColumnResizerClickEvent {
+    /**
+     * Browser event.
+     */
     originalEvent: React.MouseEvent<HTMLElement>;
+    /**
+     * DOM element of the column.
+     */
     element: HTMLElement;
+    /**
+     * Properties of the column.
+     */
     column: Column;
 }
 
-interface DataTablePageParams {
+/**
+ * Custom pagination event
+ */
+interface DataTablePageEvent {
+    /**
+     * Index of the first row.
+     */
     first: number;
+    /**
+     * Rows per page.
+     */
     rows: number;
+    /**
+     * The page number of the datatable.
+     */
     page?: number;
+    /**
+     * Total number of pages.
+     */
     pageCount?: number;
+    /**
+     * Extra options.
+     */
+    [key: string]: any;
 }
 
-interface DataTableSortParams {
+/**
+ * Custom sort event.
+ * @event
+ */
+interface DataTableSortEvent {
+    /**
+     * Field to sort against.
+     */
     sortField: string;
-    sortOrder: DataTableSortOrderType;
-    multiSortMeta: DataTableMultiSortMetaType;
+    /**
+     * Sort order as integer.
+     */
+    sortOrder: 1 | 0 | -1 | null | undefined;
+    /**
+     * MultiSort metadata.
+     */
+    multiSortMeta: DataTableSortMeta[] | null | undefined;
+    /**
+     * Extra options.
+     */
+    [key: string]: any;
 }
 
-interface DataTableFilterParams {
+/**
+ * Custom filter event.
+ * @see {@link DataTableProps.onFilter}
+ * @event
+ */
+interface DataTableFilterEvent {
+    /**
+     * Collection of active filters.
+     */
     filters: DataTableFilterMeta;
-}
-
-interface DataTablePFSEvent extends DataTablePageParams, DataTableSortParams, DataTableFilterParams {
+    /**
+     * Extra options.
+     */
     [key: string]: any;
 }
 
-interface DataTableDataSelectableParams {
-    data: any;
+/**
+ * Custom data selectable event.
+ * @see {@link DataTableProps.isDataSelectable}
+ * @event
+ */
+interface DataTableDataSelectableEvent<TValue extends DataTableValueArray> {
+    /**
+     * Original data of the row.
+     */
+    data: DataTableRowDataArray<TValue>;
+    /**
+     * Index of the row.
+     */
     index: number;
 }
 
-interface DataTableSelectionChangeParams {
+/**
+ * Custom selection change event.
+ * @see {@link DataTableProps.onContextMenuSelectionChange}, {@link DataTableProps.onSelectionChange}
+ * @event
+ */
+interface DataTableSelectionChangeEvent<TValue extends DataTableValueArray> {
+    /**
+     * Browser event.
+     */
     originalEvent: React.SyntheticEvent;
-    value: any;
+    /**
+     * Selection object.
+     */
+    value: DataTableSelection<TValue>;
+    /**
+     * Type of the selection.
+     */
     type?: string;
+    /**
+     * Extra options.
+     */
     [key: string]: any;
 }
 
-interface DataTableSelectAllChangeParams {
+/**
+ * Custom select all change event.
+ * @see {@link DataTableProps.onSelectAllChange}
+ */
+interface DataTableSelectAllChangeEvent {
+    /**
+     * Browser event.
+     */
     originalEvent: React.SyntheticEvent;
+    /**
+     * Whether all data is selected.
+     */
     checked: boolean;
 }
 
-interface DataTableRowEventParams {
+/**
+ * Custom context menu event.
+ * @see {@link DataTableProps.onContextMenu}, {@link DataTableProps.onRowCollapse}, {@link DataTableProps.onRowExpand}
+ * @event
+ */
+interface DataTableRowEvent {
+    /**
+     * Original event instance.
+     */
     originalEvent: React.SyntheticEvent;
-    data: any;
+    /**
+     * Original rows data.
+     */
+    data: DataTableValue;
 }
 
-interface DataTableRowMouseEventParams extends Omit<DataTableRowEventParams, 'originalEvent'> {
+/**
+ * Custom row mouse event.
+ * @see {@link DataTableProps.onRowMouseEnter}, {@link DataTableProps.onRowMouseLeave}
+ * @extends DataTableRowEvent
+ */
+interface DataTableRowMouseEvent extends Omit<DataTableRowEvent, 'originalEvent'> {
+    /**
+     * Browser event.
+     */
     originalEvent: React.MouseEvent<HTMLElement>;
+    /**
+     * Clicked row data index
+     */
     index: number;
 }
 
-interface DataTableRowClickEventParams extends DataTableRowMouseEventParams {}
+/**
+ * Custom row click event.
+ * @see {@link DataTableProps.onRowClick}, {@link DataTableProps.onRowDoubleClick}
+ * @extends DataTableRowMouseEvent
+ * @event
+ */
+interface DataTableRowClickEvent extends DataTableRowMouseEvent {}
 
-interface DataTableCellClickEventParams {
+/**
+ * Custom cell click event.
+ * @see {@link DataTableProps.onCellClick}
+ */
+interface DataTableCellClickEvent<TValue extends DataTableValueArray> {
+    /**
+     * Browser event.
+     */
     originalEvent: React.MouseEvent<HTMLElement>;
+    /**
+     * Value of the cell.
+     */
     value: any;
+    /**
+     * Column field.
+     */
     field: string;
-    rowData: any;
+    /**
+     * Data of the row.
+     */
+    rowData: DataTableRowData<TValue>;
+    /**
+     * Index of the row.
+     */
     rowIndex: number;
+    /**
+     * Index of the cell.
+     */
     cellIndex: number;
+    /**
+     * Whether the cell is selected or not.
+     */
     selected: boolean;
 }
 
-interface DataTableRowEditParams extends DataTableRowEventParams {
+/**
+ * Custom row edit event.
+ * @see {@link DataTableProps.onRowEditInit}, {@link DataTableProps.onRowEditChange}, {@link DataTableProps.onRowEditCancel}
+ * @extends DataTableRowEvent
+ * @event
+ */
+interface DataTableRowEditEvent extends DataTableRowEvent {
+    /**
+     * Index of the row.
+     */
     index: number;
 }
 
-interface DataTableRowEditSaveParams extends DataTableRowEditParams {
+/**
+ * Custom row edit save event.
+ * @see {@link DataTableProps.onRowEditSave}
+ * @extends DataTableRowEditEvent
+ */
+interface DataTableRowEditSaveEvent extends DataTableRowEditEvent {
+    /**
+     * Whether the row is valid or not.
+     */
     valid: boolean;
 }
 
-interface DataTableRowEditCompleteParams extends DataTableRowEventParams {
-    newData: any;
+/**
+ * Custom row edit complete event.
+ * @see {@link DataTableProps.onRowEditComplete}
+ * @extends DataTableRowEvent
+ * @event
+ */
+interface DataTableRowEditCompleteEvent extends DataTableRowEvent {
+    /**
+     * Editing rows data.
+     */
+    newData: DataTableValue;
+    /**
+     * Column field.
+     */
     field: string;
+    /**
+     * Current editing row data index.
+     */
     index: number;
 }
 
-interface DataTableSelectParams {
+/**
+ * Custom select event.
+ * @see {@link DataTableProps.onAllRowsSelect}, {@link DataTableProps.onRowSelect}
+ * @event
+ */
+interface DataTableSelectEvent {
+    /**
+     * Browser event.
+     */
     originalEvent: React.SyntheticEvent;
+    /**
+     * Selected rows data.
+     */
     data: any;
-    type: DataTableSelectType;
+    /**
+     * Type of the selection, valid value is "all".
+     */
+    type: 'row' | 'cell' | 'checkbox' | 'radio' | 'all' | undefined;
 }
 
-interface DataTableUnselectParams extends DataTableSelectParams {}
+/**
+ * Custom unselect event.
+ * @see {@link DataTableProps.onAllRowsUnselect}, {@link DataTableProps.onRowUnselect}
+ * @extends DataTableSelectEvent
+ * @event
+ */
+interface DataTableUnselectEvent extends DataTableSelectEvent {}
 
-interface DataTableExportFunctionParams {
-    data: any;
+/**
+ * Custom export function event.
+ * @see {@link DataTableProps.exportFunction}
+ * @event
+ */
+interface DataTableExportFunctionEvent<TValue extends DataTableValueArray> {
+    /**
+     * Field data.
+     */
+    data: DataTableRowDataArray<TValue>;
+    /**
+     * Column field.
+     */
     field: string;
-    rowData: any;
+    /**
+     * Data of the row.
+     */
+    rowData: DataTableRowData<TValue>;
+    /**
+     * Column.
+     */
     column: Column;
 }
 
-interface DataTableColReorderParams {
+/**
+ * Custom column reorder event.
+ * @see {@link DataTableProps.onColReorder}
+ * @event
+ */
+interface DataTableColReorderEvent {
+    /**
+     * Browser event.
+     */
     originalEvent: React.DragEvent<HTMLElement>;
+    /**
+     * Index of the dragged column.
+     */
     dragIndex: number;
+    /**
+     * Index of the dropped column.
+     */
     dropIndex: number;
+    /**
+     * Columns array after reorder.
+     */
     columns: React.ReactElement;
 }
 
-interface DataTableRowReorderParams {
+/**
+ * Custom column reorder event.
+ * @see {@link DataTableProps.onRowReorder}
+ * @event
+ */
+interface DataTableRowReorderEvent<TValue extends DataTableValueArray> {
+    /**
+     * Browser event.
+     */
     originalEvent: React.DragEvent<HTMLElement>;
-    value: any;
+    /**
+     * New value after reorder.
+     */
+    value: DataTableRowDataArray<TValue>;
+    /**
+     * Index of the dragged row.
+     */
     dragIndex: number;
+    /**
+     * Index of the drop location.
+     */
     dropIndex: number;
 }
 
+/**
+ * Options for the row expansion template
+ * @see {@link DataTableProps.rowExpansionTemplate}
+ * @group Misc
+ */
 interface DataTableRowExpansionTemplate {
+    /**
+     * Index of the row.
+     */
     index: number;
+    /**
+     * Used to override the rendering of the content.
+     */
     customRendering: boolean;
 }
 
-interface DataTableRowClassNameOptions {
-    props: DataTableProps;
+/**
+ * Custom row className options.
+ * @see {@link DataTableProps.rowClassName}
+ * @group Misc
+ */
+interface DataTableRowClassNameOptions<TValue extends DataTableValueArray> {
+    /**
+     * The props of the datatable.
+     */
+    props: DataTableProps<TValue>;
 }
 
-interface DataTableCellClassNameOptions {
-    props: DataTableProps;
-    rowData: any;
+/**
+ * Custom cell className options.
+ * @see {@link DataTableProps.cellClassName}
+ * @group Misc
+ */
+interface DataTableCellClassNameOptions<TValue extends DataTableValueArray> {
+    /**
+     * The props of the datatable.
+     */
+    props: DataTableProps<TValue>;
+    /**
+     * Column element of the datatable.
+     */
     column: Column;
+    /**
+     * Column field.
+     */
+    field: string;
+    /**
+     * Whether the row is frozen or not.
+     */
+    frozenRow: boolean;
+    /**
+     * Index of the row.
+     */
+    rowIndex: number;
 }
 
-interface DataTableShowSelectionElementOptions {
+/**
+ * Custom show selection element options.
+ * @see {@link DataTableProps.showSelectionElement}
+ * @group Misc
+ */
+interface DataTableShowSelectionElementOptions<TValue extends DataTableValueArray> {
+    /**
+     * Index of the row.
+     */
     rowIndex: number;
-    props: DataTableProps;
+    /**
+     * The props of the datatable.
+     */
+    props: DataTableProps<TValue>;
 }
 
-interface DataTableShowRowReorderElementOptions {
+/**
+ * Custom show row reorder element options.
+ * @see {@link DataTableProps.showRowReorderElement}
+ * @group Misc
+ */
+interface DataTableShowRowReorderElementOptions<TValue extends DataTableValueArray> {
+    /**
+     * Index of the row element.
+     */
     rowIndex: number;
-    props: DataTableProps;
-}
-
-interface DataTableRowEditValidatorOptions {
-    props: DataTableProps;
-}
-
-export interface DataTableProps extends Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLDivElement>, HTMLDivElement>, 'size' | 'onContextMenu' | 'ref'> {
-    id?: string;
-    value?: any[];
-    alwaysShowPaginator?: boolean;
-    autoLayout?: boolean;
-    breakpoint?: string;
-    cellSelection?: boolean;
-    className?: string;
-    collapsedRowIcon?: string;
-    columnResizeMode?: DataTableColumnResizeModeType;
-    compareSelectionBy?: DataTableCompareSelectionByType;
-    contextMenuSelection?: object;
-    csvSeparator?: string;
-    currentPageReportTemplate?: string;
-    dataKey?: string;
-    defaultSortOrder?: DataTableSortOrderType;
-    dragSelection?: boolean;
-    editMode?: string;
-    editingRows?: any[] | DataTableEditingRows;
-    emptyMessage?: DataTableEmptyMessageType;
-    expandableRowGroups?: boolean;
-    expandedRowIcon?: string;
-    expandedRows?: any[] | DataTableExpandedRows;
-    exportFilename?: string;
-    filterDelay?: number;
-    filterDisplay?: DataTableFilterDisplayType;
-    filterLocale?: string;
-    filters?: DataTableFilterMeta;
-    first?: number;
-    footer?: DataTableFooterTemplateType;
-    footerColumnGroup?: React.ReactNode;
-    frozenValue?: any[];
-    frozenWidth?: string;
-    globalFilter?: DataTableGlobalFilterType;
-    globalFilterFields?: string[];
-    globalFilterMatchMode?: ColumnFilterMatchModeType;
-    groupRowsBy?: string;
-    header?: DataTableHeaderTemplateType;
-    headerColumnGroup?: React.ReactNode;
-    lazy?: boolean;
-    loading?: boolean;
-    loadingIcon?: string;
-    metaKeySelection?: boolean;
-    multiSortMeta?: DataTableMultiSortMetaType;
-    pageLinkSize?: number;
-    paginator?: boolean;
-    paginatorClassName?: string;
-    paginatorDropdownAppendTo?: DataTableAppendToType;
-    paginatorLeft?: React.ReactNode;
-    paginatorPosition?: DataTablePaginatorPositionType;
-    paginatorRight?: React.ReactNode;
-    paginatorTemplate?: PaginatorTemplate;
-    removableSort?: boolean;
-    reorderableColumns?: boolean;
-    reorderableRows?: boolean;
-    resizableColumns?: boolean;
-    responsiveLayout?: DataTableResponsiveLayoutType;
-    rowGroupFooterTemplate?: DataTableRowGroupFooterTemplateType;
-    rowGroupHeaderTemplate?: DataTableRowGroupHeaderTemplateType;
-    rowGroupMode?: string;
-    rowHover?: boolean;
-    rows?: number;
-    rowsPerPageOptions?: number[];
-    scrollDirection?: DataTableScrollDirectionType;
-    scrollHeight?: string;
-    scrollable?: boolean;
-    selectAll?: boolean;
-    selectOnEdit?: boolean;
-    selection?: any | any[];
-    selectionAutoFocus?: boolean;
-    selectionAriaLabel?: string;
-    selectionMode?: DataTableSelectionModeType;
-    selectionPageOnly?: boolean;
-    showGridlines?: boolean;
-    showSelectAll?: boolean;
-    size?: DataTableSizeType;
-    sortField?: string;
-    sortMode?: DataTableSortModeType;
-    sortOrder?: DataTableSortOrderType;
-    stateKey?: string;
-    stateStorage?: DataTableStateStorageType;
-    stripedRows?: boolean;
-    style?: React.CSSProperties;
-    tabIndex?: number;
-    tableClassName?: string;
-    tableStyle?: React.CSSProperties;
-    totalRecords?: number;
-    virtualScrollerOptions?: VirtualScrollerProps;
-    cellClassName?(value: any, options: DataTableCellClassNameOptions): object | string;
-    customRestoreState?(): object;
+    /**
+     * The props of the datatable.
+     */
+    props: DataTableProps<TValue>;
+}
+
+/**
+ * Custom row edit validator options.
+ * @see {@link DataTableProps.rowEditValidator}
+ * @group Misc
+ */
+interface DataTableRowEditValidatorOptions<TValue extends DataTableValueArray> {
+    /**
+     * The props of the datatable.
+     */
+    props: DataTableProps<TValue>;
+}
+
+interface DataTableValue extends Record<string, any> {}
+
+interface DataTableValueArray extends Array<DataTableValue> {}
+
+/**
+ * @group Misc
+ */
+type DataTableRowData<TValue extends DataTableValueArray> = {
+    [K in keyof TValue]: TValue[K];
+};
+
+/**
+ * @group Misc
+ */
+type DataTableRowDataArray<TValue extends DataTableValueArray> = DataTableRowData<TValue>[];
+
+/**
+ * @group Misc
+ */
+type DataTableCellSelection<TValue extends DataTableValueArray> = {
+    /**
+     * Index of the cell.
+     */
+    cellIndex: number;
+    /**
+     * Column element of the datatable.
+     */
+    column: Column;
+    /**
+     * Column field.
+     */
+    field: string;
+    /**
+     * Properties of the column.
+     */
+    props: ColumnProps;
+    /**
+     * Data of the row.
+     */
+    rowData: DataTableRowData<TValue>;
+    /**
+     * Index of the row.
+     */
+    rowIndex: number;
+    /**
+     * Whether the row is selected or not.
+     */
+    selected: boolean;
+    /**
+     * Value of the cell.
+     */
+    value: TValue[keyof TValue];
+};
+
+/**
+ * @group Misc
+ */
+type DataTableSelection<TValue extends DataTableValueArray> = DataTableRowData<TValue> | DataTableRowDataArray<TValue> | DataTableCellSelection<TValue>;
+
+/**
+ * Defines valid properties in DataTable component. In addition to these, all properties of HTMLDivElement can be used in this component.
+ * @group Properties
+ */
+export interface DataTableProps<TValue extends DataTableValueArray> extends Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLDivElement>, HTMLDivElement>, 'size' | 'onContextMenu' | 'ref' | 'value'> {
+    /**
+     * Unique identifier of the element.
+     */
+    id?: string | undefined;
+    /**
+     * An array of objects to display.
+     */
+    value?: TValue | undefined;
+    /**
+     * Whether to show it even there is only one page.
+     * @defaultValue true
+     */
+    alwaysShowPaginator?: boolean | undefined;
+    /**
+     * Whether the cell widths scale according to their content or not.
+     * @defaultValue false
+     */
+    autoLayout?: boolean | undefined;
+    /**
+     * The breakpoint to define the maximum width boundary when using stack responsive layout.
+     * @defaultValue 960px
+     */
+    breakpoint?: string | undefined;
+    /**
+     * Whether to cell selection is enabled or not.
+     * @defaultValue false
+     */
+    cellSelection?: boolean | undefined;
+    /**
+     * Style class of the component.
+     */
+    className?: string | undefined;
+    /**
+     * Icon of the row toggler to display the row as collapsed.
+     * @defaultValue pi pi-chevron-up
+     */
+    collapsedRowIcon?: string | undefined;
+    /**
+     * Used to define the resize mode of the columns, valid values are "fit" and "expand".
+     * @defaultValue fit
+     */
+    columnResizeMode?: 'fit' | 'expand' | undefined;
+    /**
+     * Algorithm to define if a row is selected, valid values are "equals" that compares by reference and "deepEquals" that compares all fields.
+     * @defaultValue deepEquals
+     */
+    compareSelectionBy?: 'deepEquals' | 'equals' | undefined;
+    /**
+     * Selected row in single mode or an array of values in multiple mode.
+     */
+    contextMenuSelection?: object | undefined;
+    /**
+     * Character to use as the csv separator.
+     * @defaultValue ,
+     */
+    csvSeparator?: string | undefined;
+    /**
+     * Template of the current page report element. Available placeholders are &#123;currentPage&#125;, &#123;totalPages&#125;, &#123;rows&#125;, &#123;first&#125;, &#123;last&#125; and &#123;totalRecords&#125;
+     * @defaultValue (&#123;currentPage&#125; of &#123;totalPages&#125;)
+     */
+    currentPageReportTemplate?: string | undefined;
+    /**
+     * Name of the field that uniquely identifies a record in the data. Should be a unique business key to prevent re-rendering.
+     * @defaultValue (&#123;currentPage&#125; of &#123;totalPages&#125;)
+     */
+    dataKey?: string | undefined;
+    /**
+     * Default sort order of an unsorted column.
+     * @defaultValue (&#123;currentPage&#125; of &#123;totalPages&#125;)
+     */
+    defaultSortOrder?: 1 | 0 | -1 | null | undefined;
+    /**
+     * When enabled, a rectangle that can be dragged can be used to make a range selection.
+     * @defaultValue false
+     */
+    dragSelection?: boolean | undefined;
+    /**
+     * Defines editing mode, options are "cell" and "row".
+     * @defaultValue cell
+     */
+    editMode?: string | undefined;
+    /**
+     * A collection of rows to represent the current editing data in row edit mode.
+     */
+    editingRows?: DataTableValueArray | DataTableEditingRows | undefined;
+    /**
+     * Text to display when there is no data.
+     */
+    emptyMessage?: React.ReactNode | ((frozen: boolean) => React.ReactNode);
+    /**
+     * Makes row groups toggleable, default is false.
+     * @defaultValue false
+     */
+    expandableRowGroups?: boolean | undefined;
+    /**
+     * Icon of the row toggler to display the row as expanded.
+     * @defaultValue pi pi-chevron-down
+     */
+    expandedRowIcon?: string | undefined;
+    /**
+     * A collection of rows or a map object row data keys that are expanded.
+     */
+    expandedRows?: DataTableValueArray | DataTableExpandedRows | undefined;
+    /**
+     * Name of the exported file.
+     * @defaultValue download
+     */
+    exportFilename?: string | undefined;
+    /**
+     * Delay in milliseconds before filtering the data.
+     * @defaultValue 300
+     */
+    filterDelay?: number | undefined;
+    /**
+     * Layout of the filter elements, valid values are "row" and "menu".
+     * @defaultValue menu
+     */
+    filterDisplay?: 'menu' | 'row' | undefined;
+    /**
+     * Locale to use in filtering. The default locale is the host environment's current locale.
+     * @defaultValue undefined
+     */
+    filterLocale?: string | undefined;
+    /**
+     * An array of FilterMetadata objects to provide external filters.
+     */
+    filters?: DataTableFilterMeta | undefined;
+    /**
+     * Index of the first row to be displayed.
+     * @defaultValue 0
+     */
+    first?: number | undefined;
+    /**
+     * Custom footer content of the table.
+     */
+    footer?: DataTableFooterTemplateType<TValue>;
+    /**
+     * ColumnGroup component for footer.
+     */
+    footerColumnGroup?: React.ReactNode | undefined;
+    /**
+     * Items of the frozen part in scrollable DataTable.
+     */
+    frozenValue?: DataTableRowDataArray<TValue>;
+    /**
+     * Width of the frozen part in scrollable DataTable.
+     */
+    frozenWidth?: string | undefined;
+    /**
+     * Value of the global filter to use in filtering.
+     */
+    globalFilter?: string | null | undefined;
+    /**
+     * Define fields to be filtered globally.
+     */
+    globalFilterFields?: string[] | undefined;
+    /**
+     * Defines filterMatchMode; "startsWith", "contains", "endsWith", "equals", "notEquals", "in", "lt", "lte", "gt", "gte" and "custom".
+     * @defaultValue contains
+     */
+    globalFilterMatchMode?: 'startsWith' | 'contains' | 'endsWith' | 'equals' | 'notEquals' | 'in' | 'lt' | 'lte' | 'gt' | 'gte' | 'custom' | undefined;
+    /**
+     * Used for either be grouped by a separate grouping row or using rowspan.
+     */
+    groupRowsBy?: string | undefined;
+    /**
+     * Custom header content of the table.
+     */
+    header?: DataTableHeaderTemplateType<TValue> | undefined;
+    /**
+     * ColumnGroup component for header.
+     */
+    headerColumnGroup?: React.ReactNode | undefined;
+    /**
+     * Defines if data is loaded and interacted with in lazy manner.
+     * @defaultValue false
+     */
+    lazy?: boolean | undefined;
+    /**
+     * Displays a loader to indicate data load is in progress.
+     * @defaultValue false
+     */
+    loading?: boolean | undefined;
+    /**
+     * The icon to show while indicating data load is in progress.
+     * @defaultValue pi pi-spinner
+     */
+    loadingIcon?: string | undefined;
+    /**
+     * Defines whether metaKey is requred or not for the selection. When true metaKey needs to be pressed to select or unselect an item and when set to false selection of each item can be toggled individually. On touch enabled devices, metaKeySelection is turned off automatically.
+     * @defaultValue true
+     */
+    metaKeySelection?: boolean | undefined;
+    /**
+     * An array of SortMeta objects to sort the data by default in multiple sort mode.
+     */
+    multiSortMeta?: DataTableSortMeta[] | null | undefined;
+    /**
+     * Number of page links to display.
+     * @defaultValue 5
+     */
+    pageLinkSize?: number | undefined;
+    /**
+     * When specified as true, enables the pagination.
+     * @defaultValue false
+     */
+    paginator?: boolean | undefined;
+    /**
+     * Style class of the paginator element.
+     */
+    paginatorClassName?: string | undefined;
+    /**
+     * DOM element instance where the overlay panel should be mounted. Valid values are any DOM Element and 'self'. The self value is used to render a component where it is located.
+     * @defaultValue document.body
+     */
+    paginatorDropdownAppendTo?: 'self' | HTMLElement | null | undefined;
+    /**
+     * Content for the left side of the paginator.
+     */
+    paginatorLeft?: React.ReactNode | undefined;
+    /**
+     * Position of the paginator, options are "top","bottom" or "both".
+     * @defaultValue bottom
+     */
+    paginatorPosition?: 'top' | 'bottom' | 'both' | undefined;
+    /**
+     * Content for the right side of the paginator.
+     */
+    paginatorRight?: React.ReactNode | undefined;
+    /**
+     * Template of the paginator. For details, refer to the template section of the paginator documentation for further options.
+     * @defaultValue FirstPageLink PrevPageLink PageLinks NextPageLink LastPageLink RowsPerPageDropdown
+     */
+    paginatorTemplate?: PaginatorTemplate | undefined;
+    /**
+     * When enabled, columns can have an un-sorted state.
+     * @defaultValue false
+     */
+    removableSort?: boolean | undefined;
+    /**
+     * When enabled, columns can be reordered using drag and drop.
+     * @defaultValue false
+     */
+    reorderableColumns?: boolean | undefined;
+    /**
+     * When enabled, rows can be reordered using drag and drop.
+     * @defaultValue false
+     */
+    reorderableRows?: boolean | undefined;
+    /**
+     * When enabled, columns can be resized using drag and drop.
+     * @defaultValue false
+     */
+    resizableColumns?: boolean | undefined;
+    /**
+     * Defines the responsive mode, valid options are "stack" and "scroll".
+     * @defaultValue stack
+     */
+    responsiveLayout?: 'scroll' | 'stack' | undefined;
+    /**
+     * Function to provide the content of row group footer.
+     */
+    rowGroupFooterTemplate?: DataTableRowGroupFooterTemplateType<TValue> | undefined;
+    /**
+     * Function to provide the content of row group header.
+     */
+    rowGroupHeaderTemplate?: DataTableRowGroupHeaderTemplateType<TValue> | undefined;
+    /**
+     * Defines the row grouping mode, valid values are "subheader" and "rowgroup".
+     */
+    rowGroupMode?: string | undefined;
+    /**
+     * When enabled, background of the rows change on hover.
+     */
+    rowHover?: boolean | undefined;
+    /**
+     * Number of rows to display per page.
+     */
+    rows?: number | undefined;
+    /**
+     * Array of integer values to display inside rows per page dropdown.
+     */
+    rowsPerPageOptions?: number[] | undefined;
+    /**
+     * Orientation of the scrolling, options are "vertical", "horizontal" and "both".
+     * @defaultValue vertical|horizontal
+     */
+    scrollDirection?: 'vertical' | 'horizontal' | 'both' | undefined;
+    /**
+     * Height of the scroll viewport.
+     */
+    scrollHeight?: string | undefined;
+    /**
+     * When specified, enables horizontal and/or vertical scrolling.
+     * @defaultValue false
+     */
+    scrollable?: boolean | undefined;
+    /**
+     * When specified, selects all rows on page.
+     * @defaultValue false
+     */
+    selectAll?: boolean | undefined;
+    /**
+     * Determines whether the cell editor will be opened when clicking to select any row on Selection and Cell Edit modes.
+     * @defaultValue true
+     */
+    selectOnEdit?: boolean | undefined;
+    /**
+     * Selected row in single mode or an array of values in multiple mode.
+     * @defaultValue true
+     */
+    selection?: DataTableSelection<TValue> | undefined;
+    /**
+     * When a selectable row is clicked on RadioButton and Checkbox selection, it automatically decides whether to focus on elements such as checkbox or radio.
+     * @defaultValue true
+     */
+    selectionAutoFocus?: boolean | undefined;
+    /**
+     * A field property from the row to add Select &#123;field&#125; and Unselect &#123;field&#125; ARIA labels to checkbox/radio buttons.
+     */
+    selectionAriaLabel?: string | undefined;
+    /**
+     * Specifies the selection mode, valid values are "single", "multiple", "radiobutton" and "checkbox".
+     */
+    selectionMode?: 'single' | 'multiple' | 'checkbox' | 'radiobutton' | undefined;
+    /**
+     * When enabled with paginator and checkbox selection mode, the select all checkbox in the header will select all rows on the current page.
+     * @defaultValue false
+     */
+    selectionPageOnly?: boolean | undefined;
+    /**
+     * Whether to show grid lines between cells.
+     * @defaultValue false
+     */
+    showGridlines?: boolean | undefined;
+    /**
+     * Whether to show the select all checkbox inside the datatable's header.
+     */
+    showSelectAll?: boolean | undefined;
+    /**
+     * Define to set alternative sizes. Valid values: "small", "normal" and "large".
+     * @defaultValue normal
+     */
+    size?: 'small' | 'normal' | 'large' | undefined;
+    /**
+     * Property of a row data used for sorting, defaults to field.
+     */
+    sortField?: string | undefined;
+    /**
+     * Defines whether sorting works on single column or on multiple columns.
+     * @defaultValue single
+     */
+    sortMode?: 'single' | 'multiple' | undefined;
+    /**
+     * Order to sort the data by default.
+     */
+    sortOrder?: 1 | 0 | -1 | null | undefined;
+    /**
+     * Unique identifier of a stateful table to use in state storage.
+     */
+    stateKey?: string | undefined;
+    /**
+     * Defines where a stateful table keeps its state, valid values are "session" for sessionStorage, "local" for localStorage and "custom".
+     * @defaultValue session
+     */
+    stateStorage?: 'session' | 'local' | 'custom' | undefined;
+    /**
+     * Whether to displays rows with alternating colors.
+     * @defaultValue false
+     */
+    stripedRows?: boolean | undefined;
+    /**
+     * Inline style of the component.
+     */
+    style?: React.CSSProperties | undefined;
+    /**
+     * Index of the element in tabbing order.
+     */
+    tabIndex?: number | undefined;
+    /**
+     * Style class of the table element.
+     */
+    tableClassName?: string | undefined;
+    /**
+     * Inline style of the table element.
+     */
+    tableStyle?: React.CSSProperties | undefined;
+    /**
+     * Number of total records, defaults to length of value when not defined.
+     */
+    totalRecords?: number | undefined;
+    /**
+     * Whether to use the virtualScroller feature. The properties of VirtualScroller component can be used like an object in it.
+     *
+     * Note: Currently only vertical orientation mode is supported.
+     */
+    virtualScrollerOptions?: VirtualScrollerProps | undefined;
+    /**
+     * Function that takes the cell data and returns an object in &#123;'styleclass' : condition&#125; format to define a classname for a particular now.
+     * @param {*} value - Value of the cell.
+     * @param {DataTableCellClassNameOptions<TValue>} options - ClassName options.
+     * @return {object | string | undefined} A string or object to define a classname for a particular cell.
+     */
+    cellClassName?(value: any, options: DataTableCellClassNameOptions<TValue>): object | string | undefined;
+    /**
+     * A function to implement custom restoreState with stateStorage="custom". Need to return state object.
+     * @return {object | undefined} Returns the state object.
+     */
+    customRestoreState?(): object | undefined;
+    /**
+     * A function to implement custom saveState with stateStorage="custom".
+     * @param {object} state - The object to be stored.
+     */
     customSaveState?(state: object): void;
-    exportFunction?(e: DataTableExportFunctionParams): any;
-    isDataSelectable?(e: DataTableDataSelectableParams): boolean | undefined | null;
-    onAllRowsSelect?(e: DataTableSelectParams): void;
-    onAllRowsUnselect?(e: DataTableUnselectParams): void;
-    onCellClick?(e: DataTableCellClickEventParams): void;
-    onCellSelect?(e: DataTableSelectParams): void;
-    onCellUnselect?(e: DataTableUnselectParams): void;
-    onColReorder?(e: DataTableColReorderParams): void;
-    onColumnResizeEnd?(e: DataTableColumnResizeEndParams): void;
-    onColumnResizerClick?(e: DataTableColumnResizerClickParams): void;
-    onColumnResizerDoubleClick?(e: DataTableColumnResizerClickParams): void;
-    onContextMenu?(e: DataTableRowEventParams): void;
-    onContextMenuSelectionChange?(e: DataTableSelectionChangeParams): void;
-    onFilter?(e: DataTablePFSEvent): void;
-    onPage?(e: DataTablePFSEvent): void;
-    onRowClick?(e: DataTableRowClickEventParams): void;
-    onRowCollapse?(e: DataTableRowEventParams): void;
-    onRowDoubleClick?(e: DataTableRowClickEventParams): void;
-    onRowEditCancel?(e: DataTableRowEditParams): void;
-    onRowEditChange?(e: DataTableRowEditParams): void;
-    onRowEditComplete?(e: DataTableRowEditCompleteParams): void;
-    onRowEditInit?(e: DataTableRowEditParams): void;
-    onRowEditSave?(e: DataTableRowEditSaveParams): void;
-    onRowExpand?(e: DataTableRowEventParams): void;
-    onRowMouseEnter?(e: DataTableRowMouseEventParams): void;
-    onRowMouseLeave?(e: DataTableRowMouseEventParams): void;
-    onRowReorder?(e: DataTableRowReorderParams): void;
-    onRowSelect?(e: DataTableSelectParams): void;
-    onRowToggle?(e: DataTableRowToggleParams): void;
-    onRowUnselect?(e: DataTableUnselectParams): void;
-    onSelectAllChange?(e: DataTableSelectAllChangeParams): void;
-    onSelectionChange?(e: DataTableSelectionChangeParams): void;
-    onSort?(e: DataTablePFSEvent): void;
+    /**
+     * A function to implement custom export. Need to return string value.
+     * @param {DataTableExportFunctionEvent<TValue>} event - Custom export function event.
+     */
+    exportFunction?(event: DataTableExportFunctionEvent<TValue>): any;
+    /**
+     * Function that returns a boolean to decide whether the data should be selectable.
+     * @param {DataTableDataSelectableEvent<TValue>} event - Custom data selectable event.
+     */
+    isDataSelectable?(event: DataTableDataSelectableEvent<TValue>): boolean | undefined | null;
+    /**
+     * Callback to invoke when all rows are selected using the header checkbox.
+     * @param {DataTableSelectEvent} event - Custom select event.
+     */
+    onAllRowsSelect?(event: DataTableSelectEvent): void;
+    /**
+     * Callback to invoke when all rows are unselected using the header checkbox.
+     * @param {DataTableUnselectEvent} event - Custom unselect event.
+     */
+    onAllRowsUnselect?(event: DataTableUnselectEvent): void;
+    /**
+     * Callback to invoke on cell click.
+     * @param {DataTableCellClickEvent<TValue>} event - Custom cell click event.
+     */
+    onCellClick?(event: DataTableCellClickEvent<TValue>): void;
+    /**
+     * Callback to invoke on cell select.
+     * @param {DataTableSelectEvent} event - Custom select event.
+     */
+    onCellSelect?(event: DataTableSelectEvent): void;
+    /**
+     * Callback to invoke on cell unselect.
+     * @param {DataTableUnselectEvent} event - Custom unselect event.
+     */
+    onCellUnselect?(event: DataTableUnselectEvent): void;
+    /**
+     * Callback to invoke when a column is reordered.
+     * @param {DataTableColReorderEvent} event - Custom column reorder event.
+     */
+    onColReorder?(event: DataTableColReorderEvent): void;
+    /**
+     * Callback to invoke when a column is resized.
+     * @param {DataTableColumnResizeEndEvent} event - Custom column resize end event.
+     */
+    onColumnResizeEnd?(event: DataTableColumnResizeEndEvent): void;
+    /**
+     * Callback to invoke when a resizer element is clicked.
+     * @param {DataTableColumnResizerClickEvent} event - Custom column resizer click event.
+     */
+    onColumnResizerClick?(event: DataTableColumnResizerClickEvent): void;
+    /**
+     * Callback to invoke when a resizer element is double clicked.
+     * @param {DataTableColumnResizerClickEvent} event - Custom column resizer double click event.
+     */
+    onColumnResizerDoubleClick?(event: DataTableColumnResizerClickEvent): void;
+    /**
+     * Callback to invoke when a context menu is clicked.
+     * @param {DataTableRowEvent} event - Custom row event.
+     */
+    onContextMenu?(event: DataTableRowEvent): void;
+    /**
+     * Callback to invoke when a row selected with right click.
+     * @param {DataTableRowEvent} event - Custom row event.
+     */
+    onContextMenuSelectionChange?(event: DataTableSelectionChangeEvent<TValue>): void;
+    /**
+     * Callback to invoke on filtering.
+     * @param {DataTableFilterEvent} event - Custom filter event.
+     */
+    onFilter?(event: DataTableFilterEvent): void;
+    /**
+     * Callback to invoke on pagination.
+     * @param {DataTablePageEvent} event - Custom pagination event.
+     */
+    onPage?(event: DataTablePageEvent): void;
+    /**
+     * Callback to invoke when a row is clicked.
+     * @param {DataTableRowClickEvent} event - Custom row click event.
+     */
+    onRowClick?(event: DataTableRowClickEvent): void;
+    /**
+     * Callback to invoke when a row is collapsed.
+     * @param {DataTableRowEvent} event - Custom row event.
+     */
+    onRowCollapse?(event: DataTableRowEvent): void;
+    /**
+     * Callback to invoke when a row is double clicked.
+     * @param {DataTableRowClickEvent} event - Custom click event.
+     */
+    onRowDoubleClick?(event: DataTableRowClickEvent): void;
+    /**
+     * Callback to invoke when the cancel icon is clicked on row editing mode.
+     * @param {DataTableRowEditEvent} event - Custom row edit event.
+     */
+    onRowEditCancel?(event: DataTableRowEditEvent): void;
+    /**
+     * Callback to invoke when the cancel icon is clicked on row editing mode.
+     * @param {DataTableRowEditEvent} event - Custom row edit event.
+     */
+    onRowEditChange?(event: DataTableRowEditEvent): void;
+    /**
+     * Callback to invoke when row edit is completed.
+     * @param {DataTableRowEditCompleteEvent} event - Custom row edit complete event.
+     */
+    onRowEditComplete?(event: DataTableRowEditCompleteEvent): void;
+    /**
+     * Callback to invoke when the editing icon is clicked on row editing mode.
+     * @param {DataTableRowEditEvent} event - Custom row edit event.
+     */
+    onRowEditInit?(event: DataTableRowEditEvent): void;
+    /**
+     * Callback to invoke when the save icon is clicked on row editing mode.
+     * @param {DataTableRowEditSaveEvent} event - Custom row edit save event.
+     */
+    onRowEditSave?(event: DataTableRowEditSaveEvent): void;
+    /**
+     * Callback to invoke when a row is expanded.
+     * @param {DataTableRowEvent} event - Custom row event.
+     */
+    onRowExpand?(event: DataTableRowEvent): void;
+    /**
+     * Callback to invoke when a row is hovered with mouse.
+     * @param {DataTableRowMouseEvent} event - Custom row mouse event.
+     */
+    onRowMouseEnter?(event: DataTableRowMouseEvent): void;
+    /**
+     * Callback to invoke when a row is navigated away from with mouse.
+     * @param {DataTableRowMouseEvent} event - Custom row mouse event.
+     */
+    onRowMouseLeave?(event: DataTableRowMouseEvent): void;
+    /**
+     * Callback to update the new order.
+     * @param {DataTableRowReorderEvent<TValue>} event - Custom row reorder event.
+     */
+    onRowReorder?(event: DataTableRowReorderEvent<TValue>): void;
+    /**
+     * Callback to invoke when a row is selected.
+     * @param {DataTableSelectEvent} event - Custom select event.
+     */
+    onRowSelect?(event: DataTableSelectEvent): void;
+    /**
+     * Callback to invoke when a row is toggled or collapsed.
+     * @param {DataTableRowToggleEvent} event - Custom row toggle event.
+     */
+    onRowToggle?(event: DataTableRowToggleEvent): void;
+    /**
+     * Callback to invoke when a row is unselected.
+     * @param {DataTableUnselectEvent} event - Custom unselect event.
+     */
+    onRowUnselect?(event: DataTableUnselectEvent): void;
+    /**
+     * Callback to invoke when select all value changes.
+     * @param {DataTableSelectAllChangeEvent} event - Custom select all change event.
+     */
+    onSelectAllChange?(event: DataTableSelectAllChangeEvent): void;
+    /**
+     * Callback to invoke when selection changes.
+     * @param {DataTableSelectionChangeEvent<TValue>} event - Custom selection change event.
+     */
+    onSelectionChange?(event: DataTableSelectionChangeEvent<TValue>): void;
+    /**
+     * Callback to invoke on sort.
+     * @param {DataTableSortEvent} event - Custom sort event.
+     */
+    onSort?(event: DataTableSortEvent): void;
+    /**
+     * Callback to invoke table state is restored.
+     * @param {object} state - Table state.
+     */
     onStateRestore?(state: object): void;
+    /**
+     * Callback to invoke table state is saved.
+     * @param {object} state - Table state.
+     */
     onStateSave?(state: object): void;
-    onValueChange?(value: any[]): void;
-    rowClassName?(data: any, options: DataTableRowClassNameOptions): object | string;
-    rowEditValidator?(data: any, options: DataTableRowEditValidatorOptions): boolean;
-    rowExpansionTemplate?(data: any, options: DataTableRowExpansionTemplate): React.ReactNode;
-    showRowReorderElement?(data: any, options: DataTableShowRowReorderElementOptions): boolean | undefined | null;
-    showSelectionElement?(data: any, options: DataTableShowSelectionElementOptions): boolean | undefined | null;
-    children?: React.ReactNode;
+    /**
+     * Callback to invoke after filtering and sorting to pass the rendered value.
+     * @param {DataTableRowDataArray<TValue>} value - Value displayed by the table.
+     */
+    onValueChange?(value: DataTableRowDataArray<TValue>): void;
+    /**
+     * Function that takes the row data and returns an object in &#123;'styleclass' : condition&#125; format to define a classname for a particular now.
+     * @param {DataTableRowData<TValue>} data - Value displayed by the table.
+     */
+    rowClassName?(data: DataTableRowData<TValue>, options: DataTableRowClassNameOptions<TValue>): object | string | undefined;
+    /**
+     * Callback to invoke to validate the editing row when the save icon is clicked on row editing mode.
+     * @param {DataTableRowData<TValue>} data - Editing row data.
+     */
+    rowEditValidator?(data: DataTableRowData<TValue>, options: DataTableRowEditValidatorOptions<TValue>): boolean | undefined;
+    /**
+     * Function that receives the row data as the parameter and returns the expanded row content. You can override the rendering of the content by setting options.customRendering = true.
+     * @param {DataTableRowData<TValue>} data - Editing row data.
+     * @param {DataTableRowExpansionTemplate} options - Options for the row expansion template.
+     */
+    rowExpansionTemplate?(data: DataTableRowData<TValue>, options: DataTableRowExpansionTemplate): React.ReactNode;
+    /**
+     * Function that returns a boolean by passing the row data to decide if the row reorder element should be displayed per row.
+     * @param {DataTableRowData<TValue>} data - Editing row data.
+     * @param {DataTableShowRowReorderElementOptions} options - Options for the row reorder element.
+     */
+    showRowReorderElement?(data: DataTableRowData<TValue>, options: DataTableShowRowReorderElementOptions<TValue>): boolean | undefined | null;
+    /**
+     * Function that returns a boolean by passing the row data to decide if the radio or checkbox should be displayed per row.
+     * @param {DataTableRowData<TValue>} data - Editing row data.
+     * @param {DataTableShowSelectionElementOptions} options - Options for the row reorder element.
+     */
+    showSelectionElement?(data: DataTableRowData<TValue>, options: DataTableShowSelectionElementOptions<TValue>): boolean | undefined | null;
+    /**
+     * Used to get the child elements of the component.
+     * @readonly
+     */
+    children?: React.ReactNode | undefined;
 }
 
-export declare class DataTable extends React.Component<DataTableProps, any> {
+/**
+ * **PrimeReact - DataTable<TValue**
+ *
+ * _DataTable displays data in tabular format._
+ *
+ * [Live Demo](https://www.primefaces.org/primereact/datatable/)
+ * --- ---
+ * ![PrimeReact](https://www.primefaces.org/primereact/images/logo-100.png)
+ *
+ * @group Component
+ */
+export declare class DataTable<TValue extends DataTableValueArray> extends React.Component<DataTableProps<TValue>, any> {
+    /**
+     * Clears the table state.
+     */
     public clearState(): void;
+    /**
+     * Closes the current editing cell when incell editing is enabled.
+     */
     public closeEditingCell(): void;
+    /**
+     * Exports the data to CSV format.
+     * @param {object} options - Options to export
+     */
     public exportCSV(options?: { selectionOnly: boolean }): void;
-    public filter<T>(value: T, field: string, mode: DataTableFilterMatchModeType, index?: number): void;
+    /**
+     * Filters the data.
+     * @param {T} value - The filter value
+     * @param {string} field - The filter field
+     * @param {'startsWith' | 'contains' | 'notContains' | 'endsWith' | 'equals' | 'notEquals' | 'in' | 'lt' | 'lte' | 'gt' | 'gte' | 'between' | 'dateIs' | 'dateIsNot' | 'dateBefore' | 'dateAfter' | 'custom'} mode - Filter match mode
+     * @param  {number} index - Index of the filter
+     */
+    public filter<T>(
+        /**
+         * The filter value.
+         */
+        value: T,
+        /**
+         * The filter field.
+         */
+        field: string,
+        /**
+         * Filter match mode.
+         */
+        mode: 'startsWith' | 'contains' | 'notContains' | 'endsWith' | 'equals' | 'notEquals' | 'in' | 'lt' | 'lte' | 'gt' | 'gte' | 'between' | 'dateIs' | 'dateIsNot' | 'dateBefore' | 'dateAfter' | 'custom',
+        /**
+         * Index of the filter.
+         */
+        index?: number
+    ): void;
+    /**
+     * Resets sort, filter, paginator and columnorder state.
+     */
     public reset(): void;
+    /**
+     * Resets column order when reorderableColumns is enabled.
+     */
     public resetColumnOrder(): void;
+    /**
+     * Resets scroll position.
+     */
     public resetScroll(): void;
+    /**
+     * Restores the column widths.
+     */
     public restoreColumnWidths(): void;
+    /**
+     * Restores the table state.
+     */
     public restoreState(): void;
+    /**
+     * Stored states can be loaded at any time using this method if there is a stateStorage property.
+     * @param {*} state - The state to restore
+     */
     public restoreTableState(state: any): void;
+    /**
+     * Saves the state.
+     */
     public saveState(): void;
+    /**
+     * Used to get container element.
+     * @return {HTMLDivElement} Container element
+     */
     public getElement(): HTMLDivElement;
+    /**
+     * Used to get container element.
+     * @return {HTMLDivElement} Container element
+     */
     public getTable(): HTMLTableElement;
+    /**
+     * Used to get the virtual scroller.
+     */
     public getVirtualScroller(): VirtualScroller;
 }