import type { AgChartThemeOverrides } from 'ag-charts-types'; import type { AgEvent } from './agStack/interfaces/agEvent'; import type { ScrollDirection } from './agStack/interfaces/baseEvents'; import type { RowsDropParams } from './dragAndDrop/rowDragTypes'; import type { ColDef } from './entities/colDef'; import type { GridOptions } from './entities/gridOptions'; import type { RowNode } from './entities/rowNode'; import type { AgEventType, AgInternalEventType, AgPublicEventType, BuildEventTypeMap } from './eventTypes'; import type { FilterRequestSource } from './filter/iColumnFilter'; import type { CellRange, CellRangeParams } from './interfaces/IRangeService'; import type { GridState } from './interfaces/gridState'; import type { ChartType } from './interfaces/iChartOptions'; import type { Column, ColumnEventName, ColumnGroup, ColumnPinnedType, ProvidedColumnGroup } from './interfaces/iColumn'; import type { AgGridCommon, WithoutGridCommon } from './interfaces/iCommon'; import type { IFilterComp } from './interfaces/iFilter'; import type { FindMatch } from './interfaces/iFind'; import type { IRowNode, RowPinnedType } from './interfaces/iRowNode'; import type { IServerSideGroupSelectionState, IServerSideSelectionState } from './interfaces/iServerSideSelection'; import type { CellValueChange } from './interfaces/iUndoRedo'; import type { RowNodeTransaction } from './interfaces/rowNodeTransaction'; import type { ServerSideTransactionResult } from './interfaces/serverSideTransaction'; export type AgEventTypeParams = BuildEventTypeMap; newColumnsLoaded: NewColumnsLoadedEvent; columnPivotModeChanged: ColumnPivotModeChangedEvent; pivotMaxColumnsExceeded: PivotMaxColumnsExceededEvent; columnRowGroupChanged: ColumnRowGroupChangedEvent; expandOrCollapseAll: ExpandOrCollapseAllEvent; columnPivotChanged: ColumnPivotChangedEvent; gridColumnsChanged: GridColumnsChangedEvent; columnValueChanged: ColumnValueChangedEvent; columnMoved: ColumnMovedEvent; columnVisible: ColumnVisibleEvent; columnPinned: ColumnPinnedEvent; columnGroupOpened: ColumnGroupOpenedEvent; columnResized: ColumnResizedEvent; displayedColumnsChanged: DisplayedColumnsChangedEvent; virtualColumnsChanged: VirtualColumnsChangedEvent; columnHeaderMouseOver: ColumnHeaderMouseOverEvent; columnHeaderMouseLeave: ColumnHeaderMouseLeaveEvent; columnHeaderClicked: ColumnHeaderClickedEvent; columnHeaderContextMenu: ColumnHeaderContextMenuEvent; asyncTransactionsFlushed: AsyncTransactionsFlushedEvent; rowGroupOpened: RowGroupOpenedEvent; rowDataUpdated: RowDataUpdatedEvent; pinnedRowDataChanged: PinnedRowDataChangedEvent; pinnedRowsChanged: PinnedRowsChangedEvent; rangeSelectionChanged: RangeSelectionChangedEvent; cellSelectionChanged: CellSelectionChangedEvent; chartCreated: ChartCreatedEvent; chartRangeSelectionChanged: ChartRangeSelectionChangedEvent; chartOptionsChanged: ChartOptionsChangedEvent; chartDestroyed: ChartDestroyedEvent; toolPanelVisibleChanged: ToolPanelVisibleChangedEvent; toolPanelSizeChanged: ToolPanelSizeChangedEvent; modelUpdated: ModelUpdatedEvent; cutStart: CutStartEvent; cutEnd: CutEndEvent; pasteStart: PasteStartEvent; pasteEnd: PasteEndEvent; fillStart: FillStartEvent; fillEnd: FillEndEvent; cellSelectionDeleteStart: CellSelectionDeleteStartEvent; cellSelectionDeleteEnd: CellSelectionDeleteEndEvent; rangeDeleteStart: RangeDeleteStartEvent; rangeDeleteEnd: RangeDeleteEndEvent; undoStarted: UndoStartedEvent; undoEnded: UndoEndedEvent; redoStarted: RedoStartedEvent; redoEnded: RedoEndedEvent; cellClicked: CellClickedEvent; cellDoubleClicked: CellDoubleClickedEvent; cellMouseDown: CellMouseDownEvent; cellContextMenu: CellContextMenuEvent; cellValueChanged: CellValueChangedEvent; cellEditRequest: CellEditRequestEvent; rowValueChanged: RowValueChangedEvent; headerFocused: HeaderFocusedEvent; cellFocused: CellFocusedEvent; rowSelected: RowSelectedEvent; selectionChanged: SelectionChangedEvent; tooltipShow: TooltipShowEvent; tooltipHide: TooltipHideEvent; cellKeyDown: FullWidthCellKeyDownEvent | CellKeyDownEvent; cellMouseOver: CellMouseOverEvent; cellMouseOut: CellMouseOutEvent; filterChanged: FilterChangedEvent; filterModified: FilterModifiedEvent; filterUiChanged: FilterUiChangedEvent; filterOpened: FilterOpenedEvent; floatingFilterUiChanged: FloatingFilterUiChangedEvent; advancedFilterBuilderVisibleChanged: AdvancedFilterBuilderVisibleChangedEvent; sortChanged: SortChangedEvent; virtualRowRemoved: VirtualRowRemovedEvent; rowClicked: RowClickedEvent; rowDoubleClicked: RowDoubleClickedEvent; gridReady: GridReadyEvent; gridPreDestroyed: GridPreDestroyedEvent; gridSizeChanged: GridSizeChangedEvent; viewportChanged: ViewportChangedEvent; firstDataRendered: FirstDataRenderedEvent; dragStarted: DragStartedEvent; dragStopped: DragStoppedEvent; dragCancelled: DragCancelledEvent; rowEditingStarted: RowEditingStartedEvent; rowEditingStopped: RowEditingStoppedEvent; cellEditingStarted: CellEditingStartedEvent; cellEditingStopped: CellEditingStoppedEvent; bodyScroll: BodyScrollEvent; bodyScrollEnd: BodyScrollEndEvent; paginationChanged: PaginationChangedEvent; componentStateChanged: ComponentStateChangedEvent; storeRefreshed: StoreRefreshedEvent; stateUpdated: StateUpdatedEvent; columnMenuVisibleChanged: ColumnMenuVisibleChangedEvent; contextMenuVisibleChanged: ContextMenuVisibleChangedEvent; rowDragEnter: RowDragEnterEvent; rowDragMove: RowDragMoveEvent; rowDragLeave: RowDragLeaveEvent; rowDragEnd: RowDragEndEvent; rowDragCancel: RowDragCancelEvent; findChanged: FindChangedEvent; rowResizeStarted: RowResizeStartedEvent; rowResizeEnded: RowResizeEndedEvent; scrollbarWidthChanged: ScrollbarWidthChangedEvent; keyShortcutChangedCellStart: KeyShortcutChangedCellStartEvent; keyShortcutChangedCellEnd: KeyShortcutChangedCellEndEvent; pinnedHeightChanged: PinnedHeightChangedEvent; cellFocusCleared: CellFocusClearedEvent; fullWidthRowFocused: FullWidthRowFocusedEvent; checkboxChanged: CheckboxChangedEvent; heightScaleChanged: HeightScaleChangedEvent; suppressMovableColumns: SuppressMovableColumnsEvent; suppressMenuHide: SuppressMenuHideEvent; suppressFieldDotNotation: SuppressFieldDotNotationEvent; columnPanelItemDragStart: ColumnPanelItemDragStartEvent; columnPanelItemDragEnd: ColumnPanelItemDragEndEvent; bodyHeightChanged: BodyHeightChangedEvent; columnContainerWidthChanged: ColumnContainerWidthChangedEvent; displayedColumnsWidthChanged: DisplayedColumnsWidthChangedEvent; scrollVisibilityChanged: ScrollVisibilityChangedEvent; scrollGapChanged: ScrollOverflowChangedEvent; columnHoverChanged: ColumnHoverChangedEvent; flashCells: FlashCellsEvent; paginationPixelOffsetChanged: PaginationPixelOffsetChangedEvent; displayedRowsChanged: DisplayedRowsChangedEvent; leftPinnedWidthChanged: LeftPinnedWidthChangedEvent; rightPinnedWidthChanged: RightPinnedWidthChangedEvent; rowContainerHeightChanged: RowContainerHeightChangedEvent; headerHeightChanged: HeaderHeightChangedEvent; columnGroupHeaderHeightChanged: ColumnGroupHeaderHeightChangedEvent; columnHeaderHeightChanged: ColumnHeaderHeightChangedEvent; stylesChanged: StylesChangedEvent; storeUpdated: StoreUpdatedEvent; filterDestroyed: FilterDestroyedEvent; filterHandlerDestroyed: FilterHandlerDestroyedEvent; filterClosed: FilterClosedEvent; rowDataUpdateStarted: RowDataUpdateStartedEvent; rowCountReady: RowCountReadyEvent; advancedFilterEnabledChanged: AdvancedFilterEnabledChangedEvent; dataTypesInferred: DataTypesInferredEvent; fieldValueChanged: FieldValueChangedEvent; fieldPickerValueSelected: FieldPickerValueSelectedEvent; richSelectListRowSelected: RichSelectListRowSelectedEvent; sideBarUpdated: SideBarUpdatedEvent; alignedGridScroll: AlignedGridScrollEvent; alignedGridColumn: AlignedGridColumnEvent; gridOptionsChanged: GridOptionsChangedEvent; chartTitleEdit: ChartTitleEditEvent; recalculateRowBounds: RecalculateRowBoundsEvent; stickyTopOffsetChanged: StickyTopOffsetChangedEvent; overlayExclusiveChanged: AgEvent<'overlayExclusiveChanged'>; rowNodeDataChanged: RowNodeDataChangedEvent; columnsReset: ColumnsResetEvent; cellEditValuesChanged: CellEditValuesChangedEvent; filterSwitched: FilterSwitchedEvent; batchEditingStarted: BatchEditingStartedEvent; batchEditingStopped: BatchEditingStoppedEvent; bulkEditingStarted: BulkEditingStartedEvent; bulkEditingStopped: BulkEditingStoppedEvent; headerRowsChanged: AgEvent<'headerRowsChanged'>; rowExpansionStateChanged: AgEvent<'rowExpansionStateChanged'>; showRowGroupColsSetChanged: AgEvent<'showRowGroupColsSetChanged'>; rowDragVisibilityChanged: AgEvent<'rowDragVisibilityChanged'>; }>; /** Internal Interface for AG Grid Events */ export type AllEventsWithoutGridCommon = { [K in keyof AgEventTypeParams]: WithoutGridCommon[K]>; }[keyof AgEventTypeParams]; /** Union Type of all AG Grid Events */ export type AllEvents = { [K in keyof AgEventTypeParams]: AgEventTypeParams[K]; }[keyof AgEventTypeParams]; export interface AgGridEvent extends AgGridCommon, AgEvent { } export interface AgGlobalEvent extends AgGridEvent { } export type AgEventListener = (params: AgEventTypeParams[TEventType]) => void; export type AgGlobalEventListener = (eventType: T, event: AgEventTypeParams[T]) => void; export interface ModelUpdatedEvent extends AgGlobalEvent<'modelUpdated', TData, TContext> { /** If true, the grid will try and animate the rows to the new positions */ animate: boolean | undefined; /** If the grid has new data loaded, eg user called setRowData(), this will be false, * otherwise it's the same data but sorted or filtered, in which case this is true, and rows * can animate around (eg rowNode id 24 is the same row node as last time). */ keepRenderedRows: boolean | undefined; /** If true, then this update was a result of setRowData() getting called. This * gets the grid to scroll to the top again. */ newData: boolean | undefined; /** True when pagination and a new page is navigated to. */ newPage: boolean; /** True when page size changes from the page size selector. */ newPageSize?: boolean; /** true if all we did is changed row height, data still the same, no need to clear the undo/redo stacks */ keepUndoRedoStack?: boolean; } export interface PaginationChangedEvent extends AgGlobalEvent<'paginationChanged', TData, TContext> { /** True if rows were animated to new position */ animate?: boolean; /** True if rows were kept (otherwise complete redraw) */ keepRenderedRows?: boolean; /** True if data was new (i.e user set new data) */ newData?: boolean; /** True if user went to a new page */ newPage: boolean; /** True if user changed the page size */ newPageSize?: boolean; } export interface ToolPanelSizeChangedEvent extends AgGlobalEvent<'toolPanelSizeChanged', TData, TContext> { /** True if this is the first change to the Tool Panel size. */ started: boolean; /** True if this is the last change to the Tool Panel size. */ ended: boolean; /** New width of the ToolPanel component. */ width: number; } export interface ColumnPivotModeChangedEvent extends AgGlobalEvent<'columnPivotModeChanged', TData, TContext> { } export interface VirtualColumnsChangedEvent extends AgGlobalEvent<'virtualColumnsChanged', TData, TContext> { afterScroll: boolean; } /** * @deprecated v32.2 Either use `displayedColumnsChanged` which is fired at the same time, * or use one of the more specific column events. */ export interface ColumnEverythingChangedEvent extends AgGlobalEvent<'columnEverythingChanged', TData, TContext> { source: string; } export interface NewColumnsLoadedEvent extends AgGlobalEvent<'newColumnsLoaded', TData, TContext> { source: ColumnEventType; } export interface GridColumnsChangedEvent extends AgGlobalEvent<'gridColumnsChanged', TData, TContext> { } export interface DisplayedColumnsChangedEvent extends AgGlobalEvent<'displayedColumnsChanged', TData, TContext> { source: ColumnEventType; } export interface RowDataUpdatedEvent extends AgGlobalEvent<'rowDataUpdated', TData, TContext> { } export interface RowDataUpdateStartedEvent extends AgGlobalEvent<'rowDataUpdateStarted', TData, TContext> { firstRowData: TData | null; } export interface PinnedRowDataChangedEvent extends AgGlobalEvent<'pinnedRowDataChanged', TData, TContext> { } export interface PinnedHeightChangedEvent extends AgGlobalEvent<'pinnedHeightChanged', TData, TContext> { } export interface PinnedRowsChangedEvent extends AgGlobalEvent<'pinnedRowsChanged', TData, TContext> { } /** * - `api` - from API method * - `apiSelectAll` - from API methods `selectAll`/`deselectAll` * - `apiSelectAllFiltered` - from API methods `selectAllFiltered`/`deselectAllFiltered` * - `apiSelectAllCurrentPage` - from API methods `selectAllOnCurrentPage`/`deselectAllOnCurrentPage` * - `checkboxSelected` - row selection checkbox clicked * - `rowClicked` - row clicked when row selection enabled * - `rowDataChanged` - row data updated which triggered selection updates * - `rowGroupChanged` - grouping changed which updated the selection * - `selectableChanged`- selectable status of row has changed when `rowSelection.groupSelects` is `'descendants'` or `'filteredDescendants'` * - `spaceKey` - space key pressed on row * - `keyboardSelectAll` - select all via keyboard shortcut (CTRL+A) * - `uiSelectAll` - select all in header clicked * - `uiSelectAllFiltered` - select all in header clicked when `rowSelection.selectAll = 'filtered'` * - `uiSelectAllCurrentPage` - select all in header clicked when `rowSelection.selectAll = 'currentPage'` * - `masterDetail` - Syncing selection state between master row and detail grid * - 'gridInitializing' - set as part of initial state while the grid is initializing */ export type SelectionEventSourceType = 'api' | 'apiSelectAll' | 'apiSelectAllFiltered' | 'apiSelectAllCurrentPage' | 'checkboxSelected' | 'rowClicked' | 'rowDataChanged' | 'rowGroupChanged' | 'selectableChanged' | 'spaceKey' | 'keyboardSelectAll' | 'uiSelectAll' | 'uiSelectAllFiltered' | 'uiSelectAllCurrentPage' | 'masterDetail' | 'gridInitializing'; export interface SelectionChangedEvent extends AgGlobalEvent<'selectionChanged', TData, TContext> { /** The source that triggered the selection change event. */ source: SelectionEventSourceType; /** The row nodes that are selected at the time the event is generated. When selecting all nodes in SSRM or when group selecting in SSRM, this will be `null`. */ selectedNodes: IRowNode[] | null; /** The SSRM selection state. This can be referred to when `selectedNodes` is `null`. This will be `null` when using a row model other than SSRM. */ serverSideState: IServerSideSelectionState | IServerSideGroupSelectionState | null; } export type FilterChangedEventSourceType = 'api' | 'quickFilter' | 'columnFilter' | 'advancedFilter'; export interface FilterChangedEvent extends AgGlobalEvent<'filterChanged', TData, TContext> { /** * The source that triggered the filter change event. Can be one of the following: * - `api` - triggered by an API call * - `quickFilter` - triggered by user filtering from Quick Filter * - `columnFilter` - triggered by user filtering from Column Menu * - `advancedFilter` - triggered by user filtering from Advanced Filter */ source?: FilterChangedEventSourceType; /** True if the filter was changed as a result of data changing */ afterDataChange?: boolean; /** True if filter was changed via floating filter */ afterFloatingFilter?: boolean; /** * Columns affected by the filter change. Array contents depend on the source of the event. * * - Expect 1 element for UI-driven column filter changes. * - Expect 0-N elements (all affected columns) for calls to `api.setFilterModel()`. * - Expect 0-N elements (removed columns) for calls to `api.setColumnDefs()`. * - Expect 0 elements for quick-filters and calls to `api.onFilterChanged()`. */ columns: Column[]; } export interface FilterModifiedEvent extends AgGlobalEvent<'filterModified', TData, TContext> { filterInstance: IFilterComp; column: Column; } export interface FilterUiChangedEvent extends AgGlobalEvent<'filterUiChanged', TData, TContext> { column: Column; } export interface FilterOpenedEvent extends AgGlobalEvent<'filterOpened', TData, TContext> { /** Column / ProvidedColumnGroup that contains the filter */ column: Column | ProvidedColumnGroup; /** Source of the open request */ source: FilterRequestSource; /** Parent element of the filter */ eGui: HTMLElement; } export interface FloatingFilterUiChangedEvent extends AgGlobalEvent<'floatingFilterUiChanged', TData, TContext> { column: Column; } export interface FindChangedEvent extends AgGlobalEvent<'findChanged', TData, TContext> { /** The current search value. */ findSearchValue: string | undefined; /** The active match, or `undefined` if no active match. */ activeMatch: FindMatch | undefined; /** The total number of matches in the grid. */ totalMatches: number; } export interface SortChangedEvent extends AgGlobalEvent<'sortChanged', TData, TContext> { /** Source of the sort change. */ source: string; /** * The list of columns impacted by the sort change. */ columns?: Column[]; } export interface GridReadyEvent extends AgGlobalEvent<'gridReady', TData, TContext> { } export interface GridPreDestroyedEvent extends AgGlobalEvent<'gridPreDestroyed', TData, TContext> { /** Current state of the grid */ state: GridState; } export interface ColumnContainerWidthChanged extends AgGlobalEvent<'columnContainerWidthChanged', TData, TContext> { } export interface DisplayedColumnsWidthChangedEvent extends AgGlobalEvent<'displayedColumnsWidthChanged', TData, TContext> { } export interface ColumnHoverChangedEvent extends AgGlobalEvent<'columnHoverChanged', TData, TContext> { } export interface BodyHeightChangedEvent extends AgGlobalEvent<'bodyHeightChanged', TData, TContext> { } export interface ComponentStateChangedEvent extends AgGlobalEvent<'componentStateChanged', TData, TContext> { } export interface ColumnPanelItemDragStartEvent extends AgGlobalEvent<'columnPanelItemDragStart', TData, TContext> { column: Column | ProvidedColumnGroup; } export interface ColumnPanelItemDragEndEvent extends AgGlobalEvent<'columnPanelItemDragEnd', TData, TContext> { } export interface AgDragEvent extends AgGlobalEvent { /** The DOM element that started the event. */ target: Element; } export interface DragStartedEvent extends AgDragEvent<'dragStarted', TData, TContext> { } export interface DragStoppedEvent extends AgDragEvent<'dragStopped', TData, TContext> { } export interface DragCancelledEvent extends AgDragEvent<'dragCancelled', TData, TContext> { } export interface CheckboxChangedEvent extends AgGlobalEvent<'checkboxChanged', TData, TContext> { id: string; name: string; selected?: boolean; previousValue: boolean | undefined; } export interface GridSizeChangedEvent extends AgGlobalEvent<'gridSizeChanged', TData, TContext> { /** The grid's DIV's clientWidth */ clientWidth: number; /** The grid's DIV's clientHeight */ clientHeight: number; } export interface PivotMaxColumnsExceededEvent extends AgGlobalEvent<'pivotMaxColumnsExceeded', TData, TContext> { message: string; } interface RowResizeEvent extends AgGlobalEvent { node: IRowNode; event: MouseEvent | Touch; rowHeight: number; } export interface RowResizeStartedEvent extends RowResizeEvent { } export interface RowResizeEndedEvent extends RowResizeEvent { } export type RowDragEventType = 'rowDragEnter' | 'rowDragLeave' | 'rowDragMove' | 'rowDragEnd' | 'rowDragCancel'; export interface RowDragEvent extends AgGlobalEvent { /** The row node getting dragged. Also the node that started the drag when multi-row dragging. */ node: IRowNode; /** The list of nodes being dragged. */ nodes: IRowNode[]; /** The underlying mouse move event associated with the drag. */ event: MouseEvent; /** The `eventPath` persists the `event.composedPath()` result for access within AG Grid event handlers. */ eventPath?: EventTarget[]; /** Direction of the drag, either `'up'`, `'down'` or `null` (if mouse is moving horizontally and not vertically). */ vDirection: 'up' | 'down' | null; /** The row index the mouse is dragging over or -1 if over no row. */ overIndex: number; /** The row node the mouse is dragging over or undefined if over no row. */ overNode?: IRowNode; /** The vertical pixel location the mouse is over, with `0` meaning the top of the first row. * This can be compared to the `rowNode.rowHeight` and `rowNode.rowTop` to work out the mouse position relative to rows. * The provided attributes `overIndex` and `overNode` means the `y` property is mostly redundant. * The `y` property can be handy if you want more information such as 'how close is the mouse to the top or bottom of the row?' */ y: number; /** Details about the row dragging drop target. */ rowsDrop: RowsDropParams | null; } export interface RowDragEnterEvent extends RowDragEvent { } export interface RowDragEndEvent extends RowDragEvent { } export interface RowDragCancelEvent extends RowDragEvent { } export interface RowDragMoveEvent extends RowDragEvent { } export interface RowDragLeaveEvent extends RowDragEvent { } export interface CutStartEvent extends AgGlobalEvent<'cutStart', TData, TContext> { source: 'api' | 'ui' | 'contextMenu'; } export interface CutEndEvent extends AgGlobalEvent<'cutEnd', TData, TContext> { source: 'api' | 'ui' | 'contextMenu'; } export interface PasteStartEvent extends AgGlobalEvent<'pasteStart', TData, TContext> { source: string; } export interface PasteEndEvent extends AgGlobalEvent<'pasteEnd', TData, TContext> { source: string; } export interface FillStartEvent extends AgGlobalEvent<'fillStart', TData, TContext> { } export interface FillEndEvent extends AgGlobalEvent<'fillEnd', TData, TContext> { initialRange: CellRange; finalRange: CellRange; } export interface CellSelectionDeleteStartEvent extends AgGlobalEvent<'cellSelectionDeleteStart', TData, TContext> { source: 'deleteKey'; } export interface CellSelectionDeleteEndEvent extends AgGlobalEvent<'cellSelectionDeleteEnd', TData, TContext> { source: 'deleteKey'; } export interface RangeDeleteStartEvent extends AgGlobalEvent<'rangeDeleteStart', TData, TContext> { source: 'deleteKey'; } export interface RangeDeleteEndEvent extends AgGlobalEvent<'rangeDeleteEnd', TData, TContext> { source: 'deleteKey'; } export interface UndoStartedEvent extends AgGlobalEvent<'undoStarted', TData, TContext> { /** Source of the event. `api` if via API method. `ui` if via keyboard shortcut. */ source: 'api' | 'ui'; } export interface UndoEndedEvent extends AgGlobalEvent<'undoEnded', TData, TContext> { /** Source of the event. `api` if via API method. `ui` if via keyboard shortcut. */ source: 'api' | 'ui'; /** `true` if any undo operations were performed. */ operationPerformed: boolean; } export interface RedoStartedEvent extends AgGlobalEvent<'redoStarted', TData, TContext> { /** Source of the event. `api` if via API method. `ui` if via keyboard shortcut. */ source: 'api' | 'ui'; } export interface RedoEndedEvent extends AgGlobalEvent<'redoEnded', TData, TContext> { /** Source of the event. `api` if via API method. `ui` if via keyboard shortcut. */ source: 'api' | 'ui'; /** `true` if any redo operations were performed. */ operationPerformed: boolean; } export interface ViewportChangedEvent extends AgGlobalEvent<'viewportChanged', TData, TContext> { /** Index of the first rendered row */ firstRow: number; /** Index of the last rendered row */ lastRow: number; } export interface FirstDataRenderedEvent extends AgGlobalEvent<'firstDataRendered', TData, TContext> { /** Index of the first rendered row */ firstRow: number; /** Index of the last rendered row */ lastRow: number; } export interface RangeSelectionChangedEvent extends AgGlobalEvent<'rangeSelectionChanged', TData, TContext> { id?: string; /** True for the first change event, otherwise false */ started: boolean; /** True for the last change event, otherwise false */ finished: boolean; } export interface CellSelectionChangedEvent extends AgGlobalEvent<'cellSelectionChanged', TData, TContext> { id?: string; /** True for the first change event, otherwise false */ started: boolean; /** True for the last change event, otherwise false */ finished: boolean; } export interface ChartCreatedEvent extends AgGlobalEvent<'chartCreated', TData, TContext> { /** Id of the created chart. This can later be used to reference the chart via api methods. */ chartId: string; } /** @deprecated v32 Use ChartCreatedEvent instead */ export interface ChartCreated extends ChartCreatedEvent { } export interface ChartRangeSelectionChangedEvent extends AgGlobalEvent<'chartRangeSelectionChanged', TData, TContext> { /** Id of the effected chart. */ chartId: string; /** Same as `chartId`. */ id: string; /** New cellRange selected. */ cellRange: CellRangeParams; } /** @deprecated v32 Use ChartRangeSelectionChangedEvent instead */ export interface ChartRangeSelectionChanged extends ChartRangeSelectionChangedEvent { } export interface ChartOptionsChangedEvent extends AgGlobalEvent<'chartOptionsChanged', TData, TContext> { /** Id of the effected chart. */ chartId: string; /** ChartType */ chartType: ChartType; /** Chart theme name of currently selected theme. */ chartThemeName: string; /** Chart options. */ chartOptions: AgChartThemeOverrides; } /** @deprecated v32 Use ChartOptionsChangedEvent instead */ export interface ChartOptionsChanged extends ChartOptionsChangedEvent { } export interface ChartDestroyedEvent extends AgGlobalEvent<'chartDestroyed', TData, TContext> { /** Id of the effected chart. */ chartId: string; } /** @deprecated v32 Use ChartDestroyedEvent instead */ export interface ChartDestroyed extends ChartDestroyedEvent { } export interface ColumnGroupOpenedEvent extends AgGlobalEvent<'columnGroupOpened', TData, TContext> { columnGroup?: ProvidedColumnGroup; columnGroups: ProvidedColumnGroup[]; } interface BaseBodyScrollEvent extends AgGlobalEvent { direction: ScrollDirection; left: number; top: number; } export interface BodyScrollEvent extends BaseBodyScrollEvent<'bodyScroll', TData, TContext> { } export interface BodyScrollEndEvent extends BaseBodyScrollEvent<'bodyScrollEnd', TData, TContext> { } interface TooltipEvent extends AgGlobalEvent { parentGui: HTMLElement; } export interface TooltipShowEvent extends TooltipEvent<'tooltipShow', TData, TContext> { tooltipGui: HTMLElement; } export interface TooltipHideEvent extends TooltipEvent<'tooltipHide', TData, TContext> { } export interface PaginationPixelOffsetChangedEvent extends AgGlobalEvent<'paginationPixelOffsetChanged', TData, TContext> { } export interface StickyTopOffsetChangedEvent extends AgEvent<'stickyTopOffsetChanged'> { offset: number; } export interface CommonCellFocusParams { /** Row index of the focused cell */ rowIndex: number | null; /** Column of the focused cell */ column: Column | string | null; /** either 'top', 'bottom' or null / undefined (if not pinned) */ rowPinned: RowPinnedType; /** Whether the cell a full width cell or a regular cell */ isFullWidthCell?: boolean; } export interface CellFocusClearedParams extends CommonCellFocusParams { } export interface CellFocusedParams extends CommonCellFocusParams { /** Whether browser focus is also set (false when editing) */ forceBrowserFocus?: boolean; /** When `forceBrowserFocus` is `true`, should scroll be prevented */ preventScrollOnBrowserFocus?: boolean; /** Previous focused cell params */ previousCellFocus?: CellFocusedParams; /** Initiating event, if any */ sourceEvent?: Event; } export interface HeaderFocusedParams { column: Column | ColumnGroup; } export interface HeaderFocusedEvent extends AgGlobalEvent<'headerFocused', TData, TContext>, HeaderFocusedParams { } export interface CellFocusClearedEvent extends AgGlobalEvent<'cellFocusCleared', TData, TContext>, CellFocusClearedParams { } export interface CellFocusedEvent extends AgGlobalEvent<'cellFocused', TData, TContext>, CellFocusedParams { } export interface FullWidthRowFocusedEvent extends AgGlobalEvent<'fullWidthRowFocused', TData, TContext>, CellFocusedParams { fromBelow: boolean; } /** * @deprecated v32 Please use `ExpandOrCollapseAllEvent` instead. */ export interface ExpandCollapseAllEvent extends ExpandOrCollapseAllEvent { } export interface ExpandOrCollapseAllEvent extends AgGlobalEvent<'expandOrCollapseAll', TData, TContext> { source: string; } /**---------------*/ /** COLUMN EVENTS */ /**---------------*/ export type ColumnEventType = 'sizeColumnsToFit' | 'autosizeColumns' | 'autosizeColumnHeaderHeight' | 'alignedGridChanged' | 'filterChanged' | 'filterDestroyed' | 'gridOptionsChanged' | 'gridInitializing' | 'toolPanelDragAndDrop' | 'toolPanelUi' | 'uiColumnMoved' | 'uiColumnResized' | 'uiColumnDragged' | 'uiColumnExpanded' | 'uiColumnSorted' | 'contextMenu' | 'columnMenu' | 'rowModelUpdated' | 'rowDataUpdated' | 'api' | 'flex' | 'pivotChart' | 'columnRowGroupChanged' | 'cellDataTypeInferred' | 'rowNumbersService' | 'viewportSizeFeature'; export interface ColumnEvent extends AgGridEvent { /** The impacted column, only set if action was on one column */ column: Column | null; /** List of all impacted columns */ columns: Column[] | null; /** String describing where the event is coming from */ source: ColumnEventType; } export interface ColumnResizedEvent extends ColumnEvent<'columnResized', TData, TContext> { /** Set to true for last event in a sequence of move events */ finished: boolean; /** Any columns resized due to flex */ flexColumns: Column[] | null; } export interface ColumnPivotChangedEvent extends ColumnEvent<'columnPivotChanged', TData, TContext> { } export interface ColumnRowGroupChangedEvent extends ColumnEvent<'columnRowGroupChanged', TData, TContext> { } export interface ColumnValueChangedEvent extends ColumnEvent<'columnValueChanged', TData, TContext> { } export interface ColumnMovedEvent extends ColumnEvent<'columnMoved', TData, TContext> { /** The position the column was moved to */ toIndex?: number; /** `True` when the column has finished moving. */ finished: boolean; } export interface ColumnVisibleEvent extends ColumnEvent<'columnVisible', TData, TContext> { /** True if column was set to visible, false if set to hide, undefined if in a single call some columns were shown while others hidden */ visible?: boolean; } export interface ColumnPinnedEvent extends ColumnEvent<'columnPinned', TData, TContext> { /** Either 'left', 'right', or null (it not pinned) */ pinned: ColumnPinnedType; } export interface ColumnHeaderMouseOverEvent extends AgGlobalEvent<'columnHeaderMouseOver', TData, TContext> { /** Column or column-group related to the header that triggered the event */ column: Column | ProvidedColumnGroup; } export interface ColumnHeaderMouseLeaveEvent extends AgGlobalEvent<'columnHeaderMouseLeave', TData, TContext> { /** Column or column-group related to the header that triggered the event */ column: Column | ProvidedColumnGroup; } export interface ColumnHeaderClickedEvent extends AgGlobalEvent<'columnHeaderClicked', TData, TContext> { /** Column or column-group related to the header that triggered the event */ column: Column | ProvidedColumnGroup; } export interface ColumnHeaderContextMenuEvent extends AgGlobalEvent<'columnHeaderContextMenu', TData, TContext> { /** Column or column-group related to the header that triggered the event */ column: Column | ProvidedColumnGroup; } /**-------------------*/ /** VISIBILITY EVENTS */ /**-------------------*/ export interface ContextMenuVisibleChangedEvent extends AgGlobalEvent<'contextMenuVisibleChanged', TData, TContext> { /** True if now visible; false if now hidden. */ visible: boolean; /** Source of the visibility status change. */ source: 'api' | 'ui'; } export interface AdvancedFilterBuilderVisibleChangedEvent extends AgGlobalEvent<'advancedFilterBuilderVisibleChanged', TData, TContext> { /** True if now visible; false if now hidden. */ visible: boolean; /** Source of the visibility status change. */ source: 'api' | 'ui'; } export interface ToolPanelVisibleChangedEvent extends AgGlobalEvent<'toolPanelVisibleChanged', TData, TContext> { /** True if now visible; false if now hidden. */ visible: boolean; source: 'sideBarButtonClicked' | 'sideBarInitializing' | 'api'; /** Key of tool panel. */ key: string; /** True if switching between tool panels. False if showing/hiding. */ switchingToolPanel: boolean; } export interface ColumnMenuVisibleChangedEvent extends AgGlobalEvent<'columnMenuVisibleChanged', TData, TContext> { /** True if now visible; false if now hidden. */ visible: boolean; /** True if switching between tabs. False if showing/hiding. Only applies to legacy tabbed menu. */ switchingTab: boolean; /** * Currently displayed menu/tab. * If filter launched from floating filter, will be `'floatingFilter'`. * If using `columnMenu = 'new'` (default behaviour), will be `'columnMenu'` for the column menu, * `'columnFilter'` for the column filter, and `'columnChooser'` for the column chooser. * If using AG Grid Enterprise and `columnMenu = 'legacy'`, * will be the tab `'generalMenuTab'`, `'filterMenuTab'` or `'columnsMenuTab'`. * If using AG Grid Community and `columnMenu = 'legacy'`, will be `'columnMenu'`. */ key: 'generalMenuTab' | 'filterMenuTab' | 'columnsMenuTab' | 'columnMenu' | 'columnFilter' | 'floatingFilter' | 'columnChooser'; /** * Column the menu is opened for. Will be `null` if not launched from a column * (e.g. column chooser from the API, or column menu via right-click on a column group or empty header). */ column: Column | null; /** * Column group the menu is opened for if launched from right-click on a column group */ columnGroup?: ProvidedColumnGroup | null; } /**--------------*/ /** BATCH EVENTS */ /**--------------*/ interface BatchEditingEvent extends AgGlobalEvent { changes?: CellValueChange[]; } export interface BatchEditingStartedEvent extends BatchEditingEvent<'batchEditingStarted', TData, TContext> { } export interface BatchEditingStoppedEvent extends BatchEditingEvent<'batchEditingStopped', TData, TContext> { } /**---------------------*/ /** BULK EDITING EVENTS */ /**---------------------*/ interface BulkEditingEvent extends AgGlobalEvent { changes?: CellValueChange[]; } export interface BulkEditingStartedEvent extends BulkEditingEvent<'bulkEditingStarted', TData, TContext> { } export interface BulkEditingStoppedEvent extends BulkEditingEvent<'bulkEditingStopped', TData, TContext> { } /**------------*/ /** ROW EVENTS */ /**------------*/ interface BaseRowEvent extends AgGlobalEvent { /** The row node. */ node: IRowNode; /** The visible row index for the row */ rowIndex: number | null; /** Either 'top', 'bottom' or null / undefined (if not set) */ rowPinned: RowPinnedType; /** If event was due to browser event (eg click), this is the browser event */ event?: Event | null; /** If the browser `event` is present the `eventPath` persists the `event.composedPath()` result for access within AG Grid event handlers. */ eventPath?: EventTarget[]; } export interface RowEvent extends BaseRowEvent { /** The user provided data for the row. Data is `undefined` for row groups. */ data: TData | undefined; } /** Base interface for row events that always have data set. */ interface RowWithDataEvent extends BaseRowEvent { /** The user provided data for the row. */ data: TData; } export interface RowGroupOpenedEvent extends RowEvent<'rowGroupOpened', TData, TContext> { /** True if the group is expanded. */ expanded: boolean; } export interface RowValueChangedEvent extends RowEvent<'rowValueChanged', TData, TContext> { } export interface RowSelectedEvent extends RowEvent<'rowSelected', TData, TContext> { source: SelectionEventSourceType; } export interface VirtualRowRemovedEvent extends RowEvent<'virtualRowRemoved', TData, TContext> { } interface RowMouseEvent extends RowEvent { /** `true` if `suppressMouseEventHandling` has been implemented in the corresponding cell renderer params and has returned `true`. */ isEventHandlingSuppressed: boolean; } export interface RowClickedEvent extends RowMouseEvent<'rowClicked', TData, TContext> { } export interface RowDoubleClickedEvent extends RowMouseEvent<'rowDoubleClicked', TData, TContext> { } export interface RowEditingStartedEvent extends RowEvent<'rowEditingStarted', TData, TContext> { } export interface RowEditingStoppedEvent extends RowEvent<'rowEditingStopped', TData, TContext> { } export interface FullWidthCellKeyDownEvent extends RowEvent<'cellKeyDown', TData, TContext> { } /**------------*/ /** CELL EVENTS */ /**------------*/ export interface CellEvent extends RowEvent { column: Column; colDef: ColDef; /** The value for the cell if available otherwise undefined. */ value: TValue | null | undefined; } /** Use for cell events that will always have a data property. */ interface CellWithDataEvent extends RowWithDataEvent { column: Column; colDef: ColDef; /** The value for the cell */ value: TValue | null | undefined; } export interface CellKeyDownEvent extends CellEvent<'cellKeyDown', TData, TValue, TContext> { } interface CellMouseEvent extends CellEvent { /** `true` if `suppressMouseEventHandling` has been implemented in the corresponding cell renderer params and has returned `true`. */ isEventHandlingSuppressed: boolean; } export interface CellClickedEvent extends CellMouseEvent<'cellClicked', TData, TValue, TContext> { } export interface CellMouseDownEvent extends CellMouseEvent<'cellMouseDown', TData, TValue, TContext> { } export interface CellDoubleClickedEvent extends CellMouseEvent<'cellDoubleClicked', TData, TValue, TContext> { } export interface CellMouseOverEvent extends CellEvent<'cellMouseOver', TData, TValue, TContext> { } export interface CellMouseOutEvent extends CellEvent<'cellMouseOut', TData, TValue, TContext> { } export interface CellContextMenuEvent extends CellEvent<'cellContextMenu', TData, TValue, TContext> { } export interface CellEditingStartedEvent extends CellEvent<'cellEditingStarted', TData, TValue, TContext> { } export interface CellEditingStoppedEvent extends CellEvent<'cellEditingStopped', TData, TValue, TContext> { /** The value of the cell before the edit. */ oldValue: TValue | null | undefined; /** The value produced by the editor. This is the raw editor value, not resolved through the value getter. */ newValue: TValue | null | undefined; /** Whether the value of the editor has changed. */ valueChanged: boolean; } export interface CellValueChangedEvent extends CellWithDataEvent<'cellValueChanged', TData, TValue, TContext> { /** The value of the cell before the edit. */ oldValue: TValue | null | undefined; /** The new value of the cell after the edit, resolved through the value getter if one is configured. */ newValue: TValue | null | undefined; /** The raw value from the edit, before any value getter is applied. */ newRawValue: TRawValue | null | undefined; /** The source of the value change, e.g. `'edit'`, `'paste'`, `'undo'`, `'redo'`, `'data'`. */ source: string | undefined; } export interface CellEditValuesChangedEvent extends CellWithDataEvent<'cellEditValuesChanged', TData, TValue, TContext> { /** The value of the cell before the edit. */ oldValue: TValue | null | undefined; /** The pending edit value. This is the raw value, not resolved through the value getter. */ newValue: TValue | null | undefined; /** The source of the value change, e.g. `'edit'`, `'paste'`, `'undo'`, `'redo'`, `'data'`. */ source: string | undefined; } export interface CellEditRequestEvent extends CellWithDataEvent<'cellEditRequest', TData, TValue, TContext> { /** The value of the cell before the edit. */ oldValue: TValue | null | undefined; /** The requested edit value. This is the raw value, not resolved through the value getter. */ newValue: TValue | null | undefined; /** The source of the value change, e.g. `'edit'`, `'paste'`, `'undo'`, `'redo'`, `'data'`. */ source: string | undefined; } export interface AsyncTransactionsFlushedEvent extends AgGlobalEvent<'asyncTransactionsFlushed', TData, TContext> { /** * Array of result objects. for SSRM it's always list of `ServerSideTransactionResult`. * For Client-Side Row Model it's a list of `RowNodeTransaction`. */ results: (RowNodeTransaction | ServerSideTransactionResult)[]; } /** @deprecated v32 Use AsyncTransactionsFlushedEvent */ export interface AsyncTransactionsFlushed extends AsyncTransactionsFlushedEvent { } export interface StoreRefreshedEvent extends AgGlobalEvent<'storeRefreshed', TData, TContext> { /** The route of the store which has finished refreshing, undefined if root level */ route?: string[]; } export interface StateUpdatedEvent extends AgGlobalEvent<'stateUpdated', TData, TContext> { /** * Which parts of the state triggered the update, * or `gridInitializing` when the state has been created during grid initialization, * or 'api' when the state has been set via `api.setState` */ sources: (keyof GridState | 'gridInitializing' | 'api')[]; /** The updated state */ state: GridState; } export interface ScrollVisibilityChangedEvent extends AgGlobalEvent<'scrollVisibilityChanged', TData, TContext> { } export interface ScrollOverflowChangedEvent extends AgGlobalEvent<'scrollGapChanged', TData, TContext> { } export interface StoreUpdatedEvent extends AgGlobalEvent<'storeUpdated', TData, TContext> { } export interface LeftPinnedWidthChangedEvent extends AgGlobalEvent<'leftPinnedWidthChanged', TData, TContext> { } export interface RightPinnedWidthChangedEvent extends AgGlobalEvent<'rightPinnedWidthChanged', TData, TContext> { } export interface RowContainerHeightChanged extends AgGlobalEvent<'rowContainerHeightChanged', TData, TContext> { } /**-----------------*/ /** Internal EVENTS */ /**-----------------*/ export interface FlashCellsEvent extends AgGlobalEvent<'flashCells', TData, TContext> { cells: any; } export interface DisplayedRowsChangedEvent extends AgGlobalEvent<'displayedRowsChanged', TData, TContext> { afterScroll: boolean; } export interface AdvancedFilterEnabledChangedEvent extends AgGlobalEvent<'advancedFilterEnabledChanged', TData, TContext> { enabled: boolean; } export interface DataTypesInferredEvent extends AgGlobalEvent<'dataTypesInferred', TData, TContext> { } export interface FieldValueEvent extends AgGlobalEvent { value: any; } export interface FieldPickerValueSelectedEvent extends FieldValueEvent<'fieldPickerValueSelected', TData, TContext> { fromEnterKey: boolean; } export interface RichSelectListRowSelectedEvent extends FieldValueEvent<'richSelectListRowSelected', TData, TContext> { fromEnterKey: boolean; } export interface AlignedGridColumnEvent extends AgGlobalEvent<'alignedGridColumn', TData, TContext> { event: ColumnEvent | ColumnGroupOpenedEvent; } export interface AlignedGridScrollEvent extends AgGlobalEvent<'alignedGridScroll', TData, TContext> { event: BodyScrollEvent; } export interface GridOptionsChangedEvent extends AgGlobalEvent<'gridOptionsChanged', TData, TContext> { options: GridOptions; } export interface ScrollbarWidthChangedEvent extends AgGlobalEvent<'scrollbarWidthChanged', TData, TContext> { } export interface KeyShortcutChangedCellStartEvent extends AgGlobalEvent<'keyShortcutChangedCellStart', TData, TContext> { } export interface KeyShortcutChangedCellEndEvent extends AgGlobalEvent<'keyShortcutChangedCellEnd', TData, TContext> { } export interface HeightScaleChangedEvent extends AgGlobalEvent<'heightScaleChanged', TData, TContext> { } export interface SuppressMovableColumnsEvent extends AgGlobalEvent<'suppressMovableColumns', TData, TContext> { } export interface SuppressMenuHideEvent extends AgGlobalEvent<'suppressMenuHide', TData, TContext> { } export interface SuppressFieldDotNotationEvent extends AgGlobalEvent<'suppressFieldDotNotation', TData, TContext> { } export interface ColumnContainerWidthChangedEvent extends AgGlobalEvent<'columnContainerWidthChanged', TData, TContext> { } export interface RowContainerHeightChangedEvent extends AgGlobalEvent<'rowContainerHeightChanged', TData, TContext> { } export interface HeaderHeightChangedEvent extends AgGlobalEvent<'headerHeightChanged', TData, TContext> { } export interface ColumnHeaderHeightChangedEvent extends ColumnEvent<'columnHeaderHeightChanged', TData, TContext> { } export interface ColumnGroupHeaderHeightChangedEvent extends AgGlobalEvent<'columnGroupHeaderHeightChanged', TData, TContext> { columnGroup: ColumnGroup | null; source: 'autosizeColumnGroupHeaderHeight'; } export interface StylesChangedEvent extends AgGlobalEvent<'stylesChanged', TData, TContext> { themeChanged?: boolean; headerHeightChanged?: boolean; rowHeightChanged?: boolean; listItemHeightChanged?: boolean; rowBorderWidthChanged?: boolean; } export interface RowCountReadyEvent extends AgGlobalEvent<'rowCountReady', TData, TContext> { } export interface FieldValueChangedEvent extends AgGlobalEvent<'fieldValueChanged', TData, TContext> { } export interface FieldPickerValueSelectedEvent extends AgGlobalEvent<'fieldPickerValueSelected', TData, TContext> { } export interface RichSelectListRowSelectedEvent extends AgGlobalEvent<'richSelectListRowSelected', TData, TContext> { } export interface SideBarUpdatedEvent extends AgGlobalEvent<'sideBarUpdated', TData, TContext> { } export interface ChartTitleEditEvent extends AgGlobalEvent<'chartTitleEdit', TData, TContext> { } export interface RecalculateRowBoundsEvent extends AgGlobalEvent<'recalculateRowBounds', TData, TContext> { } export interface StickyTopOffsetChangedEvent extends AgGlobalEvent<'stickyTopOffsetChanged', TData, TContext> { } export interface RowNodeDataChangedEvent extends AgGlobalEvent<'rowNodeDataChanged', TData, TContext> { node: RowNode; } export interface ColumnsResetEvent extends AgGlobalEvent<'columnsReset', TData, TContext> { source: ColumnEventType; } export interface FilterSwitchedEvent extends AgGlobalEvent<'filterSwitched', TData, TContext> { column: Column; } export interface FilterClosedEvent