Data Grid Component

The Syncfusion React Grid component is a feature-rich, customizable data grid for building responsive, high-performance applications. It supports advanced functionalities like sorting, filtering, paging, and editing, with flexible data binding to local or remote data sources. Key features include customizable columns, aggregates, row templates, and built-in support for localization. The component offers a robust API with methods for dynamic data manipulation and events for handling user interactions.

Usage

To import and use the Data Grid component in your application, use the following code snippet:

Demos

Explore the demos of the React Data Grid component. Refer to this page.

Props

The following table outlines the props for the Data Grid component:

NameTypeDefaultDescription
aggregates
null

Configures summary rows with aggregate functions. The aggregates property allows you to add summary rows to the grid, such as totals, averages, or counts. Each aggregate row can contain multiple aggregations that apply functions like sum, average, min, max, or count to specific columns.

allowKeyboard
boolean
true

Controls whether keyboard navigation is enabled for the Data Grid. By default, navigation and interaction with grid elements can be performed using keyboard shortcuts and arrow keys. When set to false, the grid's default focus navigation behavior is disabled.

autoFillSettings
undefined

Enables cell fill (autofill) behavior when selection and editing are active. Allows dragging selected cells to fill adjacent cells with repeated or sequential values.

autoFit
null

Defines the default auto-fit scope applied to columns that omit a per-column autoFit value. Determines which cells the auto-fit measurement considers: AutoFitMode.Header (header only), AutoFitMode.Content (content only), or AutoFitMode.All (widest of both).

childDataPath
string
undefined

Path to child data in the parent row object. Specifies which property contains the array of child rows for nested detail grids. Used in conjunction with detailCellRendererParams for auto-rendering.

clipMode
ClipMode | string
ClipMode.Ellipsis | 'Ellipsis'

Defines the cell content's overflow mode. The available modes are:

  • Clip - Truncates the cell content when it overflows its area.
  • Ellipsis - Displays ellipsis when the cell content overflows its area.
  • EllipsisWithTooltip - Applies an ellipsis to overflowing cell content and displays a tooltip on hover for enhanced readability.
clipboardSettings
{ enabled: true }

Configures clipboard copy and paste functionality for the grid. Enables or disables copy/paste operations on selected cells or rows.

columnChooserSettings
{ enableSearch: true, operator: 'startsWith', ignoreAccent: false, sortDirection: 'None', selectedColumns: [] }

Defines the configuration for the Column Chooser dialog, controlling both its behavior and appearance. Enables customization of:

  • Search with customizable operators
  • Diacritics‑insensitive search
  • Column ordering and sorting
  • Custom templates for header, footer, and column items
columnMenuSettings
-

Settings for the inline column menu displayed inside header cells. When enabled is true, a small per-column menu trigger will render in the header cell.

columns
[ ]

Defines the columns to be displayed in the grid. An array of ColumnProps objects that specify how each column in the grid should be configured. This includes properties like field, headerText, width, format, and more. The order of columns in the array determines their display order in the grid.

contextMenuSettings
{ enabled: false, items: [], menuSettings: {} }

Configures the context menu settings for the Data Grid component. Enables and customizes the context menu that appears on right‑click interactions. Provides options to:

  • Enable or disable the context menu
  • Define default or custom menu items
customizePivotColumn
(context: PivotColumnContext<T>) => PivotColumnOverrides | undefined
-

Returns presentation overrides for generated pivot value columns on the UI thread. Pure callbacks may run repeatedly. User presentation adjustments take precedence. Templates receive generated pivot rows, not source records. Omitted callbacks preserve defaults.

customizePivotColumnGroup
(context: PivotColumnGroupContext<T>) => PivotColumnGroupOverrides | undefined
-

Returns presentation overrides for generated pivot group headers on the UI thread. Custom header templates retain the built-in expand/collapse control. Pure callbacks may run repeatedly; exceptions propagate to the React error boundary.

dataSource
T[] | DataManager | DataResponse
[ ]

Supplies the data to be displayed in the grid. The data source can be provided as:

  • An array of JavaScript objects
  • A DataManager instance for local/remote data operations
  • A DataResponse object with processed data The grid will automatically bind to this data and render rows based on the provided records.
defaultExpandedRows
number[]
[ ]

Specifies row indices that should be expanded by default when the grid loads. Applies only when the master-detail feature enabled using isMasterDetail={true} in the grid props. Rows at these indices automatically display their detail templates on initial render.

detailCellRendererParams
undefined

Configuration and callbacks for auto-rendering nested detail grids. Enables hierarchical data display with callback-driven data binding. When provided with isMasterDetail={true}, automatically renders nested grids for expanded rows based on the specified childDataPath.

detailRowHeight
number
300

Defines the height of the detail row. By default, the detail row height is set to "300px". A custom height can be applied when the master‑detail feature is enabled isMasterDetail={true} in the grid props.

detailRowTemplate
DetailRowTemplate | ReactElement | string
-

Template for rendering the content of a detail row. Invoked for each expanded master row, providing its row data. Commonly used to render a nested Grid or other custom components.

dragAndDropSettings
{ enabled: false }

Configures row drag-and-drop between grid instances.

editSettings
{ allowAdd: false, allowEdit: false, allowDelete: false, mode: 'Normal', editOnDoubleClick: true, confirmOnEdit: true, confirmOnDelete: false, newRowPosition: 'Top' }

Configures the editing behavior of the Data Grid. The editSettings property enables and controls editing functionality. It defines which editing operations are permitted, such as adding, editing, and deleting rows, and specifies the editing mode to be used.

emptyRecordTemplate
ComponentType<void> | ReactElement | string
null

Template for displaying content when the grid has no records. Customizes what is displayed when the grid has no data to show. This can be provided as a string, React element, or a function that returns content. It provides better user experience by explaining why the grid is empty or suggesting actions to take.

enableAltRow
boolean
true

Determines whether the sf-alt-row CSS class is added to alternate rows in the Data Grid. When set to true, the grid adds the sf-alt-row class to alternate row elements. This supports alternating row styles, which can improve readability in data-dense layouts. The grid does not apply any default styling for this class. Styling must be defined externally. When set to false, the grid does not add the sf-alt-row class to any row.

enableAutoSpan
boolean
false

Enables automatic row and column span behavior for grid cells. When set to true, adjacent cells with matching values automatically merge using both row and column spanning. When set to false, automatic spanning is disabled and only explicit numeric span values are applied. Cells must have rowSpan={true} or colSpan={true} to participate in automatic spanning.

enableDevMode
boolean
true

Enables development-specific diagnostics for the grid component. When set to true, the grid outputs additional console warnings, validation messages, and debugging information to assist in identifying configuration issues and improving integration. When set to false, these development diagnostics are suppressed to reduce console noise and minimize runtime overhead. This is a non-reactive property and applies only during initial render.

enableGridChart
boolean
false

Enables chart options in the context menu.

enableHover
boolean
true

Controls whether hover effect is applied to grid rows. By default, rows are visually highlighted on pointer hover. When set to false, rows retain a static appearance regardless of pointer hover movement.

enableHtmlSanitizer
boolean
false

Controls HTML sanitization for grid content. When set to true, the grid will sanitize any suspected untrusted HTML content before rendering it. This helps prevent cross-site scripting (XSS) attacks by removing or neutralizing potentially malicious scripts and HTML.

enableStickyHeader
boolean
false

Makes the grid header remain visible during scrolling. When enabled, column headers will "sticky" to the top of the viewport and remain visible even when the user scrolls down through the grid data. This improves usability by keeping column headers in view at all times.

excludeChildrenWithFiltering
boolean
false

Excludes child nodes from filtered tree results when a parent row matches the active filter. Useful when filtering a tree should keep only matching parent rows and hide descendant rows unless they individually match. Used when isTreeMode is enabled.

filterSettings
{ enabled: false, columns: [], type: 'FilterBar', mode: 'Immediate', immediateModeDelay: 1500, ignoreAccent: false, operators: null, caseSensitive: false }

Specifies the filtering configuration for the grid, controlling the filter UI and behavior. Includes options to enable/disable filtering, set the filter UI type, define custom operators, and configure case or accent sensitivity. Used to tailor the filtering experience to match application requirements and data types.

formulaSettings
{ enabled: false }

Configures spreadsheet-style formula processing for explicitly enabled columns.

getRowHeight
(props: Partial<RowInfo<T | GroupedData<T>>>) => number
-

Gets the height of a specific row dynamically at runtime. Accepts a callback function that returns the height in pixels based on row information, allowing row-specific height customization. This property enables dynamic row sizing based on content, data values, or other custom logic.

gridLines
GridLine | string
'Default'

Configures the visibility of grid lines between cells. Determines which grid lines are displayed in the grid. Available options are:

  • Default: Shows horizontal lines only.
  • None: Displays no grid lines.
  • Both: Shows both horizontal and vertical grid lines.
  • Horizontal: Shows horizontal lines only.
  • Vertical: Shows vertical lines only.
groupSettings
{ enabled: false, columns: [], defaultExpanded: false, captionFormat: 'compact', showDropArea: false, showGroupedColumn: false, showUngroupButton: false }

Specifies the grouping configuration for the grid, enabling hierarchical data organization by column values. Controls group expansion, drag-drop UI, caption formatting, and visibility of grouped columns. Used to organize data into collapsible groups for improved readability and analysis.

height
number | string
'auto'

Sets the height of the grid component. Controls the vertical size of the grid. Can be specified as:

  • A number (interpreted as pixels).
  • A string with CSS units (e.g., '500px', '100%').
  • auto to adjust to content. When a fixed height is set, scrollbars appear automatically when content exceeds the height.
id
string
React.useId()

Specifies a unique identifier for the grid component. Provides a distinct ID for the grid instance, enabling targeted interactions, styling, or accessibility features. Used to differentiate multiple grid instances within the same application or DOM.

isMasterDetail
boolean
false

Enable master-detail (expandable rows) feature for this grid. When enabled, all data rows become expandable master rows.

isRowPinnable
(row: T) => boolean
undefined

Callback that determines whether a row is eligible for pinning. Invoked for each row to determine if pinning actions (such as context menu options) should be available for that row. Returning false disables pinning for the row.

isRowPinned
(row: T) => 'top' | 'bottom' | null | undefined
undefined

Callback that determines whether a row should be pinned and to which position. Invoked for each data row during rendering to determine its pinning bucket. Returning 'top' places the row in the top-pinned section, returning 'bottom' places it in the bottom-pinned section, and returning null or undefined places it in the regular scrollable section.

isRowSelectable
-

Callback to determine whether a row is selectable and how its checkbox renders.

isStackedHeader
boolean
-

Indicates whether the grid is currently using stacked headers.

isTreeMode
boolean
false

Enable tree mode for hierarchical data display. When enabled, uses individual tree props for configuration instead of treeDataSettings object. Provides a simplified root-level API for tree grid functionality.

loadingIndicatorSettings
{ indicatorType: LoadingIndicatorType.Spinner, params: { visible: true, thickness: '3px', animationDuration: '1s', overlay: true, size: '36px', color: Color.Primary }}

Configures loading indicator settings for the Data Grid component. Applies spinner or skeleton customization during data operations.

maxNestingDepth
number
3

Maximum nesting depth for recursive detail grids. Prevents infinite recursion when child grids also have nested children. Once nestingDepth >= maxNestingDepth, detail grids cannot have further nested grids.

modules
{}

Defines the feature modules to be injected into the Grid. Injecting modules enables optional functionality and improves tree-shaking by including only the required features in the application bundle. To enable clipboard operations such as copy, paste, cut, and copy with headers, inject the ClipboardModule.

pageSettings
{ enabled: false, currentPage: 1, pageSize: 12, pageCount: 8 }

Specifies the pagination configuration for the grid, controlling how data is divided and navigated. Includes options to enable/disable pagination, set the number of records per page, define the number of navigation links, and select the initial page. Used to tailor the pagination UI and behavior for efficient data handling.

pinningSettings
undefined

Global configuration settings for pinning behavior across both rows and columns. Controls whether pinning is enabled, which dimensions (type) are eligible, and which sides are permitted (top/bottom for rows, left/right for columns). Follows the same composition pattern as virtualizationSettings.

pivotSettings
undefined

Configures client-side relational pivoting for the Grid. Defines report fields, aggregate values, member filters, result totals, expansion defaults, generated-column limits and execution behavior. Requires PivotModule in the modules property.

query
new Query()

Defines a query to execute against the data source. Allows you to apply a predefined Query object to the data source, which can include filtering, sorting, paging, and other data operations. This is especially useful when working with remote data sources or when you need complex data operations.

reorderSettings
{ enabled: false }

Configures the column reorder feature at grid scope.

resizeSettings
{ enabled: false, mode: ResizeMode.Auto, throttle: 150, resizeKeyboardStep: 10 }

Configures the column resize feature at grid scope. Controls the resize handle rendering, drag and keyboard resize interactions, distribution mode, keyboard step, and throttle interval.

rowClass
string | ((props?: RowClassProps<T>) => string)
-

Applies a CSS class to each grid row either globally or conditionally. Accepts a static class name or a callback function that returns a class name based on row context. The callback receives a RowClassProps object with the following properties:

  • rowType – Identifies the structural role of the row: Header, Content, or Aggregate. Useful for styling header, data, or summary rows.
  • rowIndex – The zero-based index of the row.
  • data – The full data object for the row, enabling conditional styling based on field values.
rowHeight
number
null | 50

Specifies the height for all rows in the grid.

  • When a numeric value is provided, all rows will have a fixed height in pixels.
  • If rowHeight is undefined and row DOM virtualization is enabled, the height defaults to the theme property based value (e.g., Theme.Material = 50).
  • When null (default), row height is automatically calculated based on content and applied styles for grids without row DOM virtualization.
rowNumberSettings
{ enabled: false }

Configures the display of sequential row numbers in the grid.

rowTemplate
ComponentType<T> | ReactElement | string
null

Specifies a custom template for rendering rows in the grid. Allows complete customization of row rendering by providing a template that replaces the default row structure. This can be a string template, React element, or function that returns the row content.

searchSettings
{ enabled: false, fields: [], value: undefined, operator: 'contains', caseSensitive: true, ignoreAccent: false }

Specifies the search configuration for the grid, controlling how data is searched. Defines settings for enabling the search bar, specifying searchable fields, initial search terms, operators, and case/accent sensitivity. Used to customize the search experience for filtering grid data.

selectionSettings
{ enabled: true, mode: 'Single', enableToggle: false }

Configures the grid's selection settings, determines whether Single or Multiple selections are allowed. Used to customize the selection experience for user interactions.

showColumnChooser
boolean
false

Determines whether the column chooser functionality is enabled. When set to false (default), the column chooser button will be disabled in the toolbar (but still visible if included in toolbar array). When set to true, the column chooser button will be enabled and the dialog can be opened. This property controls the enabled/disabled state of the column chooser feature, not its visibility. To show the column chooser button, you must include 'ColumnChooser' in the toolbar array.

sideBar
undefined

Configures the optional grid sidebar and its tool panels.

sortSettings
{ columns: [], allowUnsort: true, enabled: false, mode: 'Multiple' }

Specifies the sorting configuration for the grid, includes options to enable/disable sorting and controlling how data is ordered. Used to customize sorting behavior for data presentation and user interactions.

textWrapSettings
{ enabled: false, wrapMode: 'Both' }

Specifies the text wrapping configuration for the grid, controlling how text is displayed. Defines the wrap mode to determine which grid sections (header, content, or both) apply text wrapping. Used to customize text display for readability and layout optimization.

theme
Theme.Material

Specifies the theme configuration for the Data Grid component. Used internally to determine default values for theme-dependent properties (e.g., row height in virtualization). The theme property defines static default values and calculations used during grid initialization and rendering, such as the default rowHeight value when row DOM virtualization is enabled. Supported themes are Theme.Material, Theme.Bootstrap, and Theme.Tailwind. Grid styling and visual appearance are controlled by importing the corresponding theme CSS files, not by the theme property alone. The theme property must be coordinated with the appropriate CSS import.

toolbar
Array<string | ToolbarItemProps>
null

Configures the grid toolbar with predefined or custom items. The toolbar property allows you to add a toolbar to the grid with both predefined actions (add, edit, delete, update, cancel, search) and custom items. Custom items can include text, template content, and click handlers.

treeColumnIndex
number
0

Column index where tree expand/collapse UI should render. Specifies which column displays the expand/collapse buttons and indentation. Used when isTreeMode is enabled.

treeDataChildrenField
string
null

Field name containing children array for nested tree data mode. Expects an array field at the specified field name containing child objects. Used when isTreeMode is enabled.

treeDataIdMapping
string
null

Unique identifier field name for parent ID tree mode. Used in conjunction with treeDataParentIdField to establish parent-child relationships. Used when isTreeMode is enabled.

treeDataParentIdField
string
null

Parent identifier field name for parent ID tree mode. References the parent node using the value from treeDataIdMapping field. Root nodes have null or undefined values in this field. Used when isTreeMode is enabled.

treeToggleNodeExpansion
(treeKey: string, rowData: TreeGridRow) => void
-

Toggles the expansion state of a specific tree node. If expanded, it collapses; if collapsed, it expands.

virtualizationSettings
{ enabled: true, type: VirtualDomType.Both, viewPortBuffer: { rows: 5, columns: 5 }, scrollMode: ScrollMode.Auto, preventMaxRenderedRows: false}

Configures virtualization behavior for grid rendering. Includes options for enabling virtualization, defining DOM type, and customizing buffer and scroll settings.

width
number | string
'auto'

Sets the width of the grid component. Controls the horizontal size of the grid. Can be specified as:

  • A number (interpreted as pixels).
  • A string with CSS units (e.g., '800px', '100%').
  • auto to adjust to parent container. When a fixed width is set, horizontal scrollbars appear automatically when content exceeds the width.

Methods

The following table outlines the methods for the Data Grid component:

NameParametersReturnsDescription
addRecord
  • data?

    : T
  • index?

    : number
  • void

    Adds a new record to the grid’s data source. Inserts a new row with the provided data at the specified index or at the start if no index is provided.


    Params:
  • data: Optional. The data object for the new record.
  • index: Optional. The index at which to insert the new record.
  • addRecordAsync
  • data?

    : T
  • index?

    : number
  • Promise<void>

    Adds a new record and resolves once the grid's UI has committed the new row. Resolves without rejecting when the add is vetoed or is a no-op.


    Params:
  • data: Optional. The data object for the new record.
  • index: Optional. The index at which to insert the new record.
  • applyFill
  • fillRange

    : AutoFillRange
  • Promise<void>

    Executes cell fill from source selection to destination range. Generates fill values based on detected patterns and applies them to grid.


    Params:
  • fillRange: The destination range to fill
  • cancelCellChanges
    -
    Promise<void>

    Cancels the current cell edit operation and discards all unsaved changes. This method can be used only when editSettings.mode is set to 'Cell'.

    cancelDataChanges
  • rowElement?

    : HTMLTableRowElement
  • void

    Aborts the active CRUD operation, exits edit mode, and restores the original row state. Typically invoked via the Cancel toolbar action or Escape key during editing.


    Params:
  • rowElement: The row element to cancel record in command editing.
  • clearCellSelection
  • cells?

    : RowCellInfo[]
  • void

    Clears cell selections in the grid. If specific cells are provided, only those cells are cleared. If no cells are provided, all cell selections are cleared. Removes highlighting and resets the cell selection state. Uses data-based format for cell specification:

    • Data-based: { rowKey: string|number, fieldNames: string[] }.

    Params:
  • cells: Optional. Array of objects specifying rows and their cells to clear in data-based format. If not provided, all cell selections are cleared.
  • clearFilter
  • fields?

    : string[]
  • void

    Clears filters applied to the specified fields or all columns in the grid. Removes filtering conditions, restoring the grid to display all data or data for specified fields. Used to programmatically reset filtering for a fresh data view.


    Params:
  • fields: Optional. An array of field names to clear filters for. If omitted, clears all filters.
  • clearFilteringAsync
  • fields

    : string[]
  • Promise<void>

    Clears filters applied to the specified fields and resolves once the grid's UI has committed the unfiltered state.


    Params:
  • fields: An array of field names to clear filters for.
  • clearGrouping
    -
    void

    Removes all active groupings and returns the grid to its default ungrouped state. Fires the onGroup event, passing 'removeall' as the operation argument to represent the clear grouping action.

    clearGroupingAsync
    -
    Promise<void>

    Removes all active groupings and resolves once the grid's UI has committed the ungrouped state.

    clearRowSelection
  • indexes

    : number[]
  • void

    Deselects specific rows by their indexes in the grid. Removes the specified rows from the current selection, updating the grid’s UI accordingly. Used to programmatically remove selection from specific rows.


    Params:
  • indexes: An array of zero-based row indexes to deselect.
  • clearSelection
    -
    void

    Clears all currently selected rows in the grid. Removes the selection state from all rows, resetting the grid’s selection UI. Used to programmatically clear all row selections.

    clearSort
  • fields?

    : string[]
  • void

    Clears sorting from all columns in the grid. Resets the grid to an unsorted state, removing all sorting applied to any columns. Used to programmatically revert the grid to its original data order.


    Params:
  • fields: Optional. An array of field names to clear sorts for. If omitted, clears all sorts.
  • clearSortingAsync
  • fields?

    : string[]
  • Promise<void>

    Clears sorting from all columns and resolves once the grid's UI has committed the unsorted state.


    Params:
  • fields: Optional. An array of field names to clear sorts for. If omitted, clears all sorts.
  • clearUndoRedoHistory
    -
    void

    Clears all undo and redo history, removing all recorded operations. Useful for resetting the history after data source changes, sorting, filtering, or other structural changes. Requires editSettings.allowUndoRedo to be enabled.

    collapseAll
    -
    void

    Collapses all grouped rows in the grid. Fires the onGroup event, passing 'collapseall' as the operation argument to represent the collapse all groups action.

    copyToClipboard
  • withHeaders?

    : boolean
  • Promise<void>

    Copies the currently selected cells or rows to the clipboard. Can optionally include column headers in the copied content.


    Params:
  • withHeaders: Optional. Includes column headers when true.
  • cutToClipboard
    -
    Promise<void>

    Cuts the current grid selection to the clipboard. The selected data is copied and then removed from the grid.

    deleteRecord
  • fieldName?

    : string
  • data?

    : T
  • void

    Deletes a record from the grid’s data source based on specified criteria or the selected row. Removes a record matching the provided field name and data, or deletes the currently selected row if no parameters are provided. Used to programmatically remove records, updating the grid’s display and data source accordingly.


    Params:
  • fieldName: Optional. The field name to match for identifying the record to delete.
  • data: Optional. The data object or array of objects to match for deletion.
  • deleteRecordAsync
  • fieldName?

    : string
  • data?

    : T
  • Promise<void>

    Deletes a record and resolves once the grid's UI has committed the removal. Resolves without rejecting when the delete is vetoed or is a no-op.


    Params:
  • fieldName: Optional. The field name to match for identifying the record to delete.
  • data: Optional. The data object or array of objects to match for deletion.
  • editCell
  • primaryKeyValue

    : string | number
  • field

    : string
  • void

    Begins editing the specified cell in the grid. This method is available only when editSettings.mode is set to 'Cell'.


    Params:
  • primaryKeyValue: The primary key value of the row containing the cell
  • field: The field name of the cell to edit
  • editRecord
  • rowElement?

    : HTMLTableRowElement
  • void

    Initiates editing for a specified row or the currently selected row. Used to programmatically trigger the editing mode for a specific or selected row.


    Params:
  • rowElement: Optional. The row element to edit. If omitted, edits the selected row.
  • expandAll
    -
    void

    Expands all grouped rows in the grid. Fires the onGroup event with the argument 'expandall' as the operation argument to represent the expand all groups action.

    filterByColumn
  • fieldName

    : string
  • filterOperator

    : string
  • filterValue

    : ValueType | ValueType[]
  • predicate?

    : string
  • caseSensitive?

    : boolean
  • ignoreAccent?

    : boolean
  • void

    Filters grid rows by a specified column with given options. Applies a filter to the column identified by its field name, using the provided operator and value, with optional predicate and sensitivity settings. Used to programmatically filter grid data based on column-specific criteria.


    Params:
  • fieldName: The field name of the column to filter.
  • filterOperator: The operator to apply (e.g., 'contains', 'equal').
  • filterValue: The value to filter against.
  • predicate: Optional. The relationship between filter queries ('AND' or 'OR').
  • caseSensitive: Optional. If true, performs case-sensitive filtering. If false, ignores case.
  • ignoreAccent: Optional. If true, ignores diacritic characters during filtering.
  • filterByColumnAsync
  • fieldName

    : string
  • filterOperator

    : string
  • filterValue

    : ValueType | ValueType[]
  • predicate?

    : string
  • caseSensitive?

    : boolean
  • ignoreAccent?

    : boolean
  • Promise<void>

    Applies a filter to a specific column and resolves once the grid's UI has committed the filtered result. Resolves without rejecting when the filter is vetoed by onFilterStart or is a no-op. Used to sequence a subsequent grid action so it operates on the post-filter grid state.


    Params:
  • fieldName: The field name of the column to filter.
  • filterOperator: The operator to apply (e.g., 'contains', 'equal').
  • filterValue: The value to filter against.
  • predicate: Optional. The relationship between filter queries ('AND' or 'OR').
  • caseSensitive: Optional. If true, performs case-sensitive filtering. If false, ignores case.
  • ignoreAccent: Optional. If true, ignores diacritic characters during filtering.
  • getColumnByField
  • field

    : string
  • Retrieves the column configuration object for a specified field name. Returns the ColumnProps object matching the provided field, enabling access to column metadata like field, header text, or formatting. Used for dynamically accessing or modifying column properties at runtime.


    Params:
  • field: The field name of the column to retrieve.
  • getColumns
    -

    Retrieves the current configuration of all columns in the grid. Returns an array of ColumnProps objects representing the grid’s column settings. Used to access column data for dynamic processing or modifications.

    getData
  • skipPage?

    : boolean
  • requiresCount?

    : boolean
  • dataSource?

    : Object[] | DataManager | DataResponse
  • T[] | Promise<Response | DataReturnType>

    Retrieves all records from the grid based on current settings. Returns an array of data objects reflecting applied pagination, filters, sorting, and searching settings. For remote data sources, returns only the current view data.


    Params:
  • skipPage: Optional. If true, excludes pagination information from the returned data.
  • requiresCount: Optional. If true, includes the total record count in the response.
  • dataSource: Defines the source of data, which can be a local array or a remote data manager.
  • getDataModule
    -

    Returns the data module used by the grid. Use this to access the current applied queries and data-related configuration settings for the grid. This includes filtering, sorting, pagination, and other data operations.

    getHiddenColumns
    -

    Retrieves an array of configuration objects for all currently hidden columns in the grid. Used to access metadata for hidden columns for dynamic processing or UI updates.

    getPersistSelectedData
    -
    T[]

    Retrieves the persistent selected data as an array of record objects. Provides access to the internal persistent selection storage maintained across paging, sorting, filtering, and other grid operations. Only returns data when persistSelection is enabled in selectionSettings.

    getPrimaryKeyFieldNames
    -
    string[]

    Retrieves the field names of the primary key columns defined in the grid. Used to identify the primary keys for data operations like updates or deletions.

    getRedoActionsCount
    -
    number

    Returns the current number of redoable actions in the history stack. After an undo operation, the undone action becomes available for redo. Requires editSettings.allowUndoRedo to be enabled.

    getRowInfo
  • target

    : Element
  • Retrieves detailed information about the row containing a specified cell element or event target. Returns a RowInfo object with metadata about the associated row, such as its index or data. Used to access row-specific details for dynamic processing or event handling.


    Params:
  • target: The cell element or event target used to identify the row.
  • getSelectedCellsData
    -

    Retrieves the selected cells grouped by row in data-based format with cell values. Returns an array of objects, each containing a row, its selected cells, and their values. Format: { rowKey: string|number, fieldNames: string[], data: { [fieldName]: value } }. In data-based mode, multiple cells in the same row are grouped together with their data values.

    getSelectedRecords
    -
    T[] | Object | null

    Retrieves the selected row data or selection metadata from the grid. Returns different types based on configuration:

    • Local data: Array of selected row data objects (T[]).
    • Remote data with persistent selection: Object with isSelectAll (boolean) and primaryKeys (string[]).
    • No selection: Empty array or null.
    getSelectedRowIndexes
    -
    number[]

    Retrieves the indexes of the currently selected rows in the grid. Used to determine which rows are currently selected for further processing.

    getUndoActionsCount
    -
    number

    Returns the current number of undoable actions in the history stack. Each committed operation (edit, add, delete, paste, autofill, batch save) counts as one action. Requires editSettings.allowUndoRedo to be enabled.

    getVisibleColumns
    -

    Retrieves an array of configuration objects for all currently visible columns in the grid. Used to access metadata for visible columns for dynamic processing or UI updates.

    goToPage
  • pageNumber

    : number
  • void

    Navigates to a specific page in the grid’s paginated data. Updates the grid to display the data for the specified page number.


    Params:
  • pageNumber: The page number to navigate to.
  • goToPageAsync
  • pageNumber

    : number
  • Promise<void>

    Navigates to a specific page and resolves once the grid's UI has committed the new page's data. Resolves without rejecting when the navigation is vetoed by onPageChangeStart or is a no-op.


    Params:
  • pageNumber: The page number to navigate to.
  • groupColumn
    -
    void

    Groups the grid by the specified column fields. The column must have allowGroup set to true as the default. Triggers onGroup event with operation argument 'add'.

    groupColumnAsync
    -
    Promise<void>

    Groups the grid by the specified column fields and resolves once the grid's UI has committed the change. Resolves without rejecting when the group is vetoed by onGroupStart or is a no-op.

    hideSpinner
    -
    void

    Hides the loading spinner overlay previously shown on the grid. Used to update the UI after completing asynchronous or time-consuming operations.

    isRemote
    -
    boolean

    Determines whether the grid is using a remote data source. Remote data sources typically involve server-side operations for pagination, filtering, sorting, and searching.

    openColumnChooser
    -
    void

    Opens the column chooser dialog programmatically. Requires the Column Chooser to be enabled showColumnChooser={true} in the grid configuration.

    pasteFromClipboard
  • clipboardText

    : string
  • void

    Pastes clipboard text into the current grid selection. The data is applied starting from the active cell or first selected row.


    Params:
  • clipboardText: Clipboard content to paste into the grid.
  • redo
    -
    Promise<void>

    Reapplies the most recently undone grid operation. Restores the committed state in the grid's canonical data source and refreshes the view. Requires editSettings.allowUndoRedo to be enabled.

    refresh
    -
    void

    Refreshes the grid’s data and view to reflect the latest state. Updates the grid’s display by re-rendering data based on current settings, such as filters, sorting, pagination or other. Used to synchronize the grid’s UI with changes in the data source or configuration.

    removeSortColumn
  • columnName

    : string
  • void

    Removes sorting from a specified column in the grid. Clears the sorting applied to the column identified by its name, reverting it to an unsorted state. Used to programmatically remove sorting from a specific column.


    Params:
  • columnName: The name of the column to remove sorting from (e.g., field name).
  • removeSortColumnAsync
  • columnName

    : string
  • Promise<void>

    Removes sorting from a specified column and resolves once the grid's UI has committed the change.


    Params:
  • columnName: The name of the column to remove sorting from (e.g., field name).
  • saveBulkChanges
    -
    void

    Updates one or more fields across multiple records in bulk.

    saveBulkChangesAsync
    -
    Promise<Object | void>

    Updates one or more fields across multiple records in bulk and resolves when the changes are saved.

    saveCellChanges
    -
    Promise<boolean>

    Saves the changes made in cell edit mode and closes the edit state. This method is available only when editSettings.mode is set to 'Cell'.. If validation is enabled, input is checked automatically; invalid cells are not saved.

    saveDataChanges
  • rowElement?

    : HTMLTableRowElement
  • Promise<boolean>

    Commits the edited or newly added row to the data source after validating inputs and triggering lifecycle events such as onDataChangeStart and onDataChangeComplete. Typically invoked via the Update toolbar action or Enter key during editing.


    Params:
  • rowElement: The row element to save record in command editing.
  • search
  • searchString?

    : string
  • void

    Searches grid records using a specified search string. Applies a search across the grid’s data based on the configured search settings, such as fields or operators. Used to programmatically filter data using a search term.


    Params:
  • searchString: Optional. The search term to apply. if omitted, clears the search.
  • searchAsync
  • searchString?

    : string
  • Promise<void>

    Searches grid records and resolves once the grid's UI has committed the search results. Resolves without rejecting when the search is vetoed by onSearchStart or is a no-op.


    Params:
  • searchString: Optional. The search term to apply. If omitted, clears the search.
  • selectCell
  • rowKey

    : string | number
  • fieldName

    : string
  • void

    Selects a single cell specified by row key and field name. When in this mode, selection persists across paging, sorting, and filtering. This is the primary method for programmatic single-cell selection.


    Params:
  • rowKey: The primary key value of the row containing the cell.
  • fieldName: The field name (column identifier) of the cell.
  • selectCells
  • cells

    : RowCellInfo[]
  • void

    Selects multiple cells specified by row keys and field names (data-based mode). When in data-based mode, selections persist across paging, sorting, and filtering. This is the primary method for programmatic cell selection.


    Params:
  • cells: Array of objects specifying rows and their selected cells in data-based format.
  • selectCellsByRange
  • start

    : CellIdentifier
  • end

    : CellIdentifier
  • void

    Selects a rectangular range of cells from start position to end position. Selection behavior depends on the configured type (Flow/Box/BoxWithBorder). Uses data-based position format to ensure selections persist across paging, sorting, and filtering. This is the primary method for programmatic range selection.


    Params:
  • start: The starting cell position (top-left corner) in data-based format {rowKey, fieldName}.
  • end: The ending cell position (bottom-right corner) in data-based format {rowKey, fieldName}.
  • selectRow
  • rowIndex

    : number
  • isToggle?

    : boolean
  • void

    Selects a single row by its index in the grid. Updates the grid’s selection state to highlight the specified row, optionally toggling the existing selection. Used to programmatically select a row based on its position.


    Params:
  • rowIndex: The zero-based index of the row to select.
  • isToggle: Optional. Specifies whether to toggle the existing selection.
  • selectRowByRange
  • startIndex

    : number
  • endIndex?

    : number
  • void

    Selects a range of rows from a start index to an optional end index in the grid. Updates the grid’s selection state to highlight all rows within the specified range. Used to programmatically select a continuous set of rows.


    Params:
  • startIndex: The zero-based index of the first row in the range.
  • endIndex: Optional. The zero-based index of the last row in the range.
  • selectRows
  • rowIndexes

    : number[]
  • void

    Selects multiple rows by their indexes in the grid. Updates the grid’s selection state to highlight the specified rows, typically used in multi-selection mode. Used to programmatically select a collection of rows.


    Params:
  • rowIndexes: An array of zero-based row indexes to select.
  • setCellValue
  • key

    : string | number
  • field

    : string
  • value

    : ValueType | null
  • isDataSourceChangeRequired?

    : boolean
  • void

    Updates a specific cell’s value in a row identified by its primary key. Modifies the cell value for the specified field in the record matching the provided key, optionally updating the data source. Requires a primary key column defined via columns.isPrimaryKey.


    Params:
  • key: The primary key value of the record containing the cell.
  • field: The field name of the column to update.
  • value: The new value for the cell.
  • isDataSourceChangeRequired: Optional. If true, updates the underlying data source.
  • setCellValueAsync
  • key

    : string | number
  • field

    : string
  • value

    : ValueType | null
  • isDataSourceChangeRequired?

    : boolean
  • Promise<void>

    Updates a specific cell’s value and resolves once the grid's UI has committed the change. Resolves without rejecting when the row is not found or is not currently rendered (no-op).


    Params:
  • key: The primary key value of the record containing the cell.
  • field: The field name of the column to update.
  • value: The new value for the cell.
  • isDataSourceChangeRequired: Optional. If true, updates the underlying data source.
  • setPagerMessage
  • message?

    : string
  • void

    Updates the text of an external message displayed in the grid. Sets or clears a custom message, typically used for notifications or status updates in the grid’s UI.


    Params:
  • message: Optional. The message text to display.
  • setRowData
  • key

    : string | number
  • data

    : T
  • isDataSourceChangeRequired?

    : boolean
  • void

    Updates and refreshes a specific row’s data based on its primary key value. Replaces the row’s data for the record matching the provided key, optionally updating the data source. Requires a primary key column defined via columns.isPrimaryKey.


    Params:
  • key: The primary key value of the record to update.
  • data: The new data object for the row.
  • isDataSourceChangeRequired: Optional. If true, updates the underlying data source.
  • setRowDataAsync
  • key

    : string | number
  • data

    : T
  • isDataSourceChangeRequired?

    : boolean
  • Promise<void>

    Updates and refreshes a specific row’s data and resolves once the grid's UI has committed the change. Resolves without rejecting when the row is not found or is not currently rendered (no-op).


    Params:
  • key: The primary key value of the record to update.
  • data: The new data object for the row.
  • isDataSourceChangeRequired: Optional. If true, updates the underlying data source.
  • showSpinner
    -
    void

    Displays a loading spinner overlay on the grid to indicate an ongoing operation. Used to enhance the user experience during asynchronous or time-consuming operations.

    sortByColumn
  • columnName

    : string
  • sortDirection

    : SortDirection | string
  • isMultiSort?

    : boolean
  • void

    Sorts a specified column in the grid with given options. Applies sorting to the column identified by its name, using the specified direction and multi-sort behavior. Used to programmatically sort grid data by a column.


    Params:
  • columnName: The name of the column to sort (e.g., field name).
  • sortDirection: The sorting direction ('Ascending' or 'Descending').
  • isMultiSort: Optional. Specifies whether to maintain previously sorted columns.
  • sortColumnAsync
  • columnName

    : string
  • sortDirection

    : SortDirection | string
  • isMultiSort?

    : boolean
  • Promise<void>

    Sorts a specified column and resolves once the grid's UI has committed the new sort order. Resolves without rejecting when the sort is vetoed by onSortStart or is a no-op. Used to sequence a subsequent grid action so it operates on the post-sort grid state.


    Params:
  • columnName: The name of the column to sort (e.g., field name).
  • sortDirection: The sorting direction ('Ascending' or 'Descending').
  • isMultiSort: Optional. Specifies whether to maintain previously sorted columns.
  • undo
    -
    Promise<void>

    Reverts the most recent grid operation (edit, add, delete, paste, autofill, or batch save). Restores the previous state in the grid's canonical data source and refreshes the view. Requires editSettings.allowUndoRedo to be enabled.

    ungroupColumn
  • fields

    : string[]
  • void

    Removes grouping for the specified column fields. Triggers onGroup event with operation argument 'remove'.


    Params:
  • fields: The collection field names of the column to ungroup.
  • ungroupColumnAsync
  • fields

    : string[]
  • Promise<void>

    Removes grouping for the specified column fields and resolves once the grid's UI has committed the change.


    Params:
  • fields: The collection field names of the column to ungroup.
  • updateRecord
  • index

    : number
  • data

    : T
  • void

    Updates a specific row in the grid with new data. Replaces the data of the row at the specified index with the provided data object. Used to programmatically modify existing row data in the grid.


    Params:
  • index: The zero-based index of the row to update.
  • data: The new data object for the row.
  • updateRecordAsync
  • index

    : number
  • data

    : T
  • Promise<void>

    Updates a specific row and resolves once the grid's UI has committed the change. Resolves without rejecting when the update is vetoed or is a no-op.


    Params:
  • index: The zero-based index of the row to update.
  • data: The new data object for the row.
  • validateEditForm
    -
    boolean

    Validates all fields in the current edit or add form against their defined rules. Checks the input values in the editing form to ensure they meet column validation criteria. Used to verify data integrity before saving changes.

    validateField
  • field

    : string
  • boolean

    Validates a specific field against its defined column validation rules. Checks the value of the specified field to ensure it meets the configured validation criteria. Used to verify the validity of a single field during editing.


    Params:
  • field: The name of the field to validate.
  • Events

    The following table outlines the events for the Data Grid component:

    NameTypeDescription
    onCellClick
    (event: CellFocusEvent<T>) => void

    Fires when a grid cell is clicked. Provides details about the clicked cell.

    onCellDeselect
    (event: CellDeselectEvent<T>) => void

    Fires after cells are successfully deselected in the grid. Provides details about the deselected cells. Only fires when selectionSettings.type is 'Cell'.

    onCellEditStart
    (event: CellEditEvent<T>) => void

    Fires when cell editing begins in Cell edit mode. Provides an opportunity to validate the target cell or cancel the edit before the editor is presented.

    onCellFillComplete

    Fires when a cell fill operation completes.

    onCellFillStart
    (args: CellFillStartedEvent) => void

    Fires when a cell fill operation begins.

    onCellFocus
    (event: CellFocusEvent<T>) => void

    Fires when a grid cell gains focus. Provides details about the focused cell.

    onCellSelect
    (event: CellSelectEvent<T>) => void

    Fires after cells are successfully selected in the grid. Provides details about the selected cells including data and positions. Only fires when selectionSettings.type is 'Cell'.

    onClipboardCopy
    (args: ClipboardCopyEvent) => void

    Fires when data is copied to the clipboard from the Grid. Triggered after the copy operation completes, providing details about the copied content, selected rows/cells, and allowing cancellation of the operation. Use Cases:

    • Audit copying operations for sensitive data
    • Modify clipboard content before writing (via beforeClipboardCopy alternative event if available)
    • Track user interactions with grid data
    • Prevent copying from specific rows or in certain conditions
    onClipboardCut
    (args: ClipboardCutEvent) => void

    Fires when data is cut from the grid using Ctrl+X. Triggered when cut operation completes, providing details about the cut content, selected rows/cells, and allowing cancellation of the operation. Use Cases:

    • Audit cutting operations for sensitive data
    • Track user interactions with grid data
    • Prevent cutting from primary key columns
    • Prevent cutting from specific rows in certain conditions
    • Log or transform cut operations before data is cleared
    onClipboardPaste
    (args: ClipboardPasteEvent) => void

    Fires when data is pasted from the clipboard into the Grid. Triggered after paste operation completes, providing details about the pasted data, target location, and allowing cancellation of the operation. Use Cases:

    • Validate pasted data before applying to grid
    • Log paste operations for compliance or audit purposes
    • Prevent pasting into read-only rows or columns
    • Transform or filter pasted content
    onColumnChooserApply
    (event: ColumnChooserApplyEvent) => void

    Fires when column changes are applied in the Column Chooser dialog. Triggered when the user clicks OK/Apply button with the final column visibility configuration. Used to track which columns were shown/hidden and perform post-apply actions.

    onColumnChooserBeforeOpen

    Fires before the Column Chooser dialog is displayed or opened. Allows customization of column visibility or cancellation before the dialog appears.

    onColumnDrag
    (event: ColumnReorderEvent<T>) => void

    Fires while a column reorder drag is in progress.

    onColumnMenuClick
    (event: ColumnMenuClickEvent) => void

    Fires when a column menu item is selected. Provides the item identifier and the target column for custom logic.

    onColumnMenuClose
    (event: ColumnMenuCloseEvent) => void

    Fires when the column menu is closed. Useful for resetting UI state after the menu finishes interacting.

    onColumnMenuOpen
    (event: ColumnMenuOpenEvent) => void | ColumnMenuOpenEvent | Promise<ColumnMenuOpenEvent>

    Fires when the column menu is opened for a specific header column. Provides the menu items and the target column for customization or cancellation.

    onColumnReorderEnd
    (event: ColumnReorderEndEvent<T>) => void

    Fires when a column reorder interaction ends.

    onColumnReorderStart

    Fires when a column reorder interaction begins.

    onColumnResize
    (event: ColumnResizeEvent) => void

    Fires as the column width changes during an active resize interaction. Triggered continuously while the user drags the resize handle, steps with the keyboard, or when a programmatic resize/auto-fit updates a column.

    onColumnResizeEnd
    (event: ColumnResizeEndEvent) => void

    Fires when a column resize interaction ends. Triggered on pointer-up of the resize handle, end of a keyboard resize step, or completion of a programmatic resize/auto-fit on each updated column.

    onColumnResizeStart
    (event: ColumnResizeStartEvent) => void

    Fires when a column resize interaction begins. Triggered on pointer-down of the resize handle, keyboard focus activation, or the start of a programmatic resize/auto-fit.

    onContextMenuClick
    (event: ContextMenuClickEvent) => void

    Fires when a context menu item is selected or clicked by the user. Handles the action associated with the selected menu item, such as Edit, Delete, Sort, etc. Provides context about the selected item, target row/column, and triggering element.

    onContextMenuClose
    ( ) => void

    Fires when the context menu is closed or hidden on the grid. Suitable for cleanup operations or resetting UI state after the context menu interaction completes. Triggered when the user dismisses the menu through selection, clicking outside, or pressing Escape.

    onContextMenuOpen
    (event: ContextMenuOpenEvent) => ContextMenuOpenEvent | Promise<ContextMenuOpenEvent>

    Fires when the context menu is about to be opened or displayed on the grid. Allows customization, validation, or cancellation of the context menu before it appears. Provides access to the target element, menu items, and associated row/column data. Supports both synchronous and asynchronous menu item loading:

    • Synchronous: Return the modified ContextMenuOpenEvent object.
    • Asynchronous: Return a Promise that resolves to the modified ContextMenuOpenEvent object.
    onDataChangeCancel
    (event: FormCancelEvent<T>) => void

    Fires when a CRUD operation is cancelled.

    onDataChangeComplete
    (event: SaveEvent<T> | DeleteEvent<T>) => void

    Fires when a create, update, or delete operation is completed.

    onDataChangeRequest
    (event: DataChangeRequestEvent<T>) => void

    Fires when the grid's data source is changed. Monitors and responds to updates in the grid's data source.

    onDataChangeStart
    (event: SaveEvent<T> | DeleteEvent<T>) => void

    Fires when a create, update, or delete operation is started.

    onDataLoad
    ( ) => void

    Fires after data is successfully bound to the grid. Suitable for actions requiring fully loaded data.

    onDataRequest
    (event: DataRequestEvent) => void

    Fires when grid data state changes due to sorting or paging. Monitors and responds to changes in grid state.

    onDeleteDialogOpen
    (eventArgs: DeleteDialogEventArgs) => void

    Fires when the bulk‑delete confirmation dialog opens with cross‑page selection enabled. Allows customization of dialog options, such as disabling specific choices or setting the default selection. Use Cases:

    • Disable "Delete Current Page": Prevents partial deletion when records are selected across multiple pages.
    • Preselect "Delete All Selected Records": Ensures this option is the default, reducing errors and maintaining consistency.
    onError
    (event: Error) => void

    Fires when grid operations like sorting or filtering fail. Provides error details for handling and user feedback.

    onFilter
    (event: FilterEvent) => void

    Fires after a filtering operation completes on the grid. Provides filter state details for post-filter actions.

    onFilterDialogAfterOpen

    Fires after the filter Dialog is fully displayed and ready for interaction. Suitable for initializing custom filter components or DOM manipulation.

    onFormRender
    (event: FormRenderEvent<T>) => void

    Fires when the edit or add form is fully loaded and ready for user input.

    onGridRenderComplete
    ( ) => void

    Fired when the grid is fully loaded and ready for user interaction. Suitable for actions requiring only on grid initially fully loaded data.

    onGridRenderStart
    ( ) => void

    Fires at the start of grid initialization before data processing. and component mount. This event is triggered during the React render phase, before the component is mounted to the DOM. Useful for initial configurations or showing loading indicators. Do not perform state updates in this callback, as they will trigger React warnings about updating unmounted components. Use onGridRenderComplete instead for state updates.

    onGroup
    (args: OnGroupArgs) => void

    Fires when a grouping operation occurs on the grid. Triggered by add/remove column, expand/collapse, or reorder group operations. Provides current grouped columns and operation type for custom handling.

    onPageChange
    (event: PageEvent) => void

    Event triggered after a paging operation is completed on the grid.

    onPinnedRowsChanged
    (event: RowPinningEvent<T>) => void

    Fires when a row changes its pinning state due to user interaction or programmatic update. Provides the affected row, its previous pin bucket, its current pin bucket, and the action performed.

    onPivotChange
    (event: PivotChangeEvent<T>) => void

    Fires after interactive pivot configuration changes are applied. Triggered when report fields, member filters, sorting, totals or other pivot settings change through the integrated pivot controls.

    onPivotError
    (event: PivotErrorEvent) => void

    Fires when pivot calculation or configuration validation fails. Triggered when the pivot report contains invalid fields or settings, unsupported data-source or scroll-mode combinations, exceeds the column limit, or encounters a calculation failure.

    onRedoComplete
    (event: RedoCompleteEvent) => void

    Fires after a Grid-level redo request completes.

    onRedoStart
    (event: RedoStartEvent) => void

    Fires before a Grid-level redo request is applied.

    onRefresh
    ( ) => void

    Fired when the grid data is refreshed or updated.

    onRowAddStart
    (event: RowAddEvent<T>) => void

    Fires when the process of adding a new row starts.

    onRowDeselect
    (event: RowSelectEvent<T>) => void

    Fires after a row is successfully deselected. Provides details about the deselected row.

    onRowDoubleClick
    (event: RecordDoubleClickEvent<T>) => void

    Fires when a grid row is clicked. Provides details about the clicked row for custom actions.

    onRowDrag
    (args: RowDragEventArgs<T>) => void

    Fires while a data row drag operation is in progress.

    onRowDragStart
    (args: RowDragEventArgs<T>) => void

    Fires when a data row drag operation starts.

    onRowDrop
    (args: RowDragEventArgs<T>) => void

    Fires when a data row drag operation ends.

    onRowEditStart
    (event: RowEditEvent<T>) => void

    Fires when editing begins on a grid record. Allows validation or field modification before editing.

    onRowSelect
    (event: RowSelectEvent<T>) => void

    Fires after a row is successfully selected. Provides details about the selected row.

    onSearch
    (event: SearchEvent) => void

    Fires after a searching operation completes on the grid. Provides search result details for post-search actions.

    onSort
    (event: SortEvent) => void

    Fires after a sorting operation completes on the grid. Provides sort state details for post-sort actions.

    onToolbarItemClick
    (event: ToolbarClickEvent) => void

    Fires when a toolbar item is clicked. Enables custom actions for toolbar buttons.

    onUndoComplete
    (event: UndoCompleteEvent) => void

    Fires after a Grid-level undo request completes.

    onUndoStart
    (event: UndoStartEvent) => void

    Fires before a Grid-level undo request is applied.

    shouldExpandGroup
    (event: ShouldExpandGroupEvent) => boolean

    Fires before a group is expanded or collapsed. Allows validation or cancellation of group expand/collapse behavior.