ag-grid-community 32.3.2 → 33.0.0

package/dist/types/src/interfaces/exportParams.d.ts

@@ -0,0 +1,153 @@
+import type { Column, ColumnGroup } from './iColumn';
+import type { AgGridCommon } from './iCommon';
+import type { IRowNode } from './iRowNode';
+import type { RowPosition } from './iRowPosition';
+export interface ExportFileNameGetterParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+}
+export type ExportFileNameGetter = (params?: ExportFileNameGetterParams) => string;
+export interface BaseExportParams {
+    /**
+     * If `true`, all columns will be exported in the order they appear in the columnDefs.
+     * When `false` only the columns currently being displayed will be exported.
+     * @default false
+     */
+    allColumns?: boolean;
+    /**
+     * Provide a list (an array) of column keys or Column objects if you want to export specific columns.
+     */
+    columnKeys?: (string | Column)[];
+    /** Row node positions. */
+    rowPositions?: RowPosition[];
+    /**
+     * String to use as the file name or a function that returns a string.
+     */
+    fileName?: string | ExportFileNameGetter;
+    /**
+     * Determines whether rows are exported before being filtered and sorted.
+     * @default 'filteredAndSorted'
+     */
+    exportedRows?: 'all' | 'filteredAndSorted';
+    /**
+     * Export only selected rows.
+     * @default false
+     */
+    onlySelected?: boolean;
+    /**
+     * Only export selected rows including other pages (only makes sense when using pagination).
+     * @default false
+     */
+    onlySelectedAllPages?: boolean;
+    /**
+     * Set to `true` to exclude header column groups.
+     * @default false
+     */
+    skipColumnGroupHeaders?: boolean;
+    /**
+     * Set to `true` if you don't want to export column headers.
+     * @default false
+     */
+    skipColumnHeaders?: boolean;
+    /**
+     * Set to `true` to skip row group headers if grouping rows. Only relevant when grouping rows.
+     * @default false
+     */
+    skipRowGroups?: boolean;
+    /**
+     * Set to `true` to suppress exporting rows pinned to the top of the grid.
+     * @default false
+     */
+    skipPinnedTop?: boolean;
+    /**
+     * Set to `true` to suppress exporting rows pinned to the bottom of the grid.
+     * @default false
+     */
+    skipPinnedBottom?: boolean;
+    /**
+     * A callback function that will be invoked once per row in the grid. Return true to omit the row from the export.
+     */
+    shouldRowBeSkipped?(params: ShouldRowBeSkippedParams): boolean;
+    /**
+     * A callback function invoked once per cell in the grid. Return a string value to be displayed in the export. For example this is useful for formatting date values.
+     */
+    processCellCallback?(params: ProcessCellForExportParams): string;
+    /**
+     * A callback function invoked once per column. Return a string to be displayed in the column header.
+     */
+    processHeaderCallback?(params: ProcessHeaderForExportParams): string;
+    /**
+     * A callback function invoked once per column group. Return a `string` to be displayed in the column group header.
+     * Note that column groups are exported by default, this option will not work with `skipColumnGroupHeaders=true`.
+     */
+    processGroupHeaderCallback?(params: ProcessGroupHeaderForExportParams): string;
+    /**
+     * A callback function invoked once per row group. Return a `string` to be displayed in the group cell.
+     */
+    processRowGroupCallback?(params: ProcessRowGroupForExportParams): string;
+}
+export interface ExportParams<T> extends BaseExportParams {
+    /**
+     * Content to put at the top of the exported sheet.
+     */
+    prependContent?: T;
+    /**
+     * Content to put at the bottom of the exported sheet.
+     */
+    appendContent?: T;
+    /** A callback function to return content to be inserted below a row in the export. */
+    getCustomContentBelowRow?: (params: ProcessRowGroupForExportParams) => T | undefined;
+}
+export type PackageFileParams<T> = T & {
+    data: string[];
+};
+export interface CsvCell {
+    /** The data that will be added to the cell. */
+    data: CsvCellData;
+    /**
+     * The number of cells to span across (1 means span 2 columns).
+     * @default 0
+     */
+    mergeAcross?: number;
+}
+export interface CsvCellData {
+    /** The value of the cell. */
+    value: string | null;
+}
+export type CsvCustomContent = CsvCell[][] | string;
+export interface CsvExportParams extends ExportParams<CsvCustomContent> {
+    /**
+     * Delimiter to insert between cell values.
+     * @default ,
+     */
+    columnSeparator?: string;
+    /**
+     * By default cell values are encoded according to CSV format rules: values are wrapped in double quotes, and any double quotes within the values are escaped, so my value becomes \"my\"\"value\". Pass `true` to insert the value into the CSV file without escaping.
+     * In this case it is your responsibility to ensure that no cells contain the columnSeparator character.
+     * @default false
+     */
+    suppressQuotes?: boolean;
+}
+export interface ShouldRowBeSkippedParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    /** Row node. */
+    node: IRowNode<TData>;
+}
+export interface ProcessCellForExportParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    value: any;
+    accumulatedRowIndex?: number;
+    node?: IRowNode<TData> | null;
+    column: Column;
+    type: string;
+    /** Utility function to parse a value using the column's `colDef.valueParser` */
+    parseValue: (value: string) => any;
+    /** Utility function to format a value using the column's `colDef.valueFormatter` */
+    formatValue: (value: any) => string;
+}
+export interface ProcessHeaderForExportParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    column: Column;
+}
+export interface ProcessGroupHeaderForExportParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    columnGroup: ColumnGroup;
+}
+export interface ProcessRowGroupForExportParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    node: IRowNode<TData>;
+    column?: Column;
+}

package/dist/types/src/interfaces/gridState.d.ts

@@ -0,0 +1,160 @@
+import type { CellRangeType } from './IRangeService';
+import type { AdvancedFilterModel } from './advancedFilterModel';
+import type { FilterModel } from './iFilter';
+import type { RowPosition } from './iRowPosition';
+import type { SortModelItem } from './iSortModelItem';
+import type { ServerSideRowGroupSelectionState, ServerSideRowSelectionState } from './selectionState';
+export interface FilterState {
+    filterModel?: FilterModel;
+    advancedFilterModel?: AdvancedFilterModel;
+}
+export interface CellSelectionCellState {
+    id?: string;
+    type?: CellRangeType;
+    /** The start row of the range */
+    startRow?: RowPosition;
+    /** The end row of the range */
+    endRow?: RowPosition;
+    /** The columns in the range */
+    colIds: string[];
+    /** The start column for the range */
+    startColId: string;
+}
+/** @deprecated v32.2 Use `CellSelectionCellState` instead. */
+export interface RangeSelectionCellState extends CellSelectionCellState {
+}
+export interface CellSelectionState {
+    cellRanges: CellSelectionCellState[];
+}
+/** @deprecated v32.2 Use `CellSelectionState` instead. */
+export interface RangeSelectionState {
+    cellRanges: RangeSelectionCellState[];
+}
+export interface ScrollState {
+    top: number;
+    left: number;
+}
+export interface FiltersToolPanelState {
+    expandedGroupIds: string[];
+    expandedColIds: string[];
+}
+export interface ColumnToolPanelState {
+    expandedGroupIds: string[];
+}
+export interface SideBarState {
+    /** Is side bar visible */
+    visible: boolean;
+    position: 'left' | 'right';
+    /** Open tool panel, or null if closed */
+    openToolPanel: string | null;
+    /** State for each tool panel */
+    toolPanels: {
+        [id: string]: any;
+    };
+}
+export interface FocusedCellState extends RowPosition {
+    colId: string;
+}
+export interface PaginationState {
+    /** Current page */
+    page?: number;
+    /** Current page size. Only use when the pageSizeSelector dropdown is visible */
+    pageSize?: number;
+}
+export interface SortState {
+    /** Sorted columns and directions in order */
+    sortModel: SortModelItem[];
+}
+export interface RowGroupState {
+    /** Grouped columns in order */
+    groupColIds: string[];
+}
+export interface AggregationColumnState {
+    colId: string;
+    /** Only named aggregation functions can be used in state */
+    aggFunc: string;
+}
+export interface AggregationState {
+    aggregationModel: AggregationColumnState[];
+}
+export interface PivotState {
+    pivotMode: boolean;
+    pivotColIds: string[];
+}
+export interface ColumnPinningState {
+    leftColIds: string[];
+    rightColIds: string[];
+}
+export interface ColumnVisibilityState {
+    hiddenColIds: string[];
+}
+export interface ColumnSizeState {
+    colId: string;
+    width?: number;
+    flex?: number;
+}
+export interface ColumnSizingState {
+    columnSizingModel: ColumnSizeState[];
+}
+export interface ColumnOrderState {
+    /** All colIds in order */
+    orderedColIds: string[];
+}
+export interface ColumnGroupState {
+    openColumnGroupIds: string[];
+}
+export interface RowGroupExpansionState {
+    expandedRowGroupIds: string[];
+}
+export interface GridState {
+    /** Grid version number */
+    version?: string;
+    /** Includes aggregation functions (column state) */
+    aggregation?: AggregationState;
+    /** Includes opened groups */
+    columnGroup?: ColumnGroupState;
+    /** Includes column ordering (column state) */
+    columnOrder?: ColumnOrderState;
+    /** Includes left/right pinned columns (column state) */
+    columnPinning?: ColumnPinningState;
+    /** Includes column width/flex (column state) */
+    columnSizing?: ColumnSizingState;
+    /** Includes hidden columns (column state) */
+    columnVisibility?: ColumnVisibilityState;
+    /** Includes Column Filters and Advanced Filter */
+    filter?: FilterState;
+    /** Includes currently focused cell. Works for Client-Side Row Model only */
+    focusedCell?: FocusedCellState;
+    /** Includes current page */
+    pagination?: PaginationState;
+    /** Includes current pivot mode and pivot columns (column state) */
+    pivot?: PivotState;
+    /** Includes currently selected cell ranges */
+    cellSelection?: CellSelectionState;
+    /**
+     * Includes currently selected cell ranges
+     * @deprecated v32.2 Use `cellSelection` instead.
+     */
+    rangeSelection?: RangeSelectionState;
+    /** Includes current row group columns (column state) */
+    rowGroup?: RowGroupState;
+    /** Includes currently expanded group rows */
+    rowGroupExpansion?: RowGroupExpansionState;
+    /**
+     * Includes currently selected rows.
+     * For Server-Side Row Model, will be `ServerSideRowSelectionState | ServerSideRowGroupSelectionState`,
+     * for other row models, will be an array of row IDs
+     */
+    rowSelection?: string[] | ServerSideRowSelectionState | ServerSideRowGroupSelectionState;
+    /** Includes current scroll position. Works for Client-Side Row Model only */
+    scroll?: ScrollState;
+    /** Includes current Side Bar positioning and opened tool panel */
+    sideBar?: SideBarState;
+    /** Includes current sort columns and direction (column state) */
+    sort?: SortState;
+    /**
+     * When providing a partial `initialState` with some but not all column state properties, set this to `true`.
+     * Not required if passing the whole state object retrieved from the grid.
+     */
+    partialColumnState?: boolean;
+}

package/dist/types/src/interfaces/groupCellRenderer.d.ts

@@ -0,0 +1,68 @@
+import type { CellRendererSelectorFunc, ColumnFunctionCallbackParams } from '../entities/colDef';
+import type { ICellRendererParams } from '../rendering/cellRenderers/iCellRenderer';
+import type { UserCompDetails } from './iUserCompDetails';
+export interface FooterValueGetterFunc {
+    (params: GroupCellRendererParams): any;
+}
+export interface TotalValueGetterFunc {
+    (params: GroupCellRendererParams): any;
+}
+export type GroupCheckboxSelectionCallbackParams<TData = any, TValue = any> = ColumnFunctionCallbackParams<TData> & GroupCellRendererParams<TData, TValue>;
+export interface GroupCheckboxSelectionCallback<TData = any, TValue = any> {
+    (params: GroupCheckboxSelectionCallbackParams<TData, TValue>): boolean;
+}
+/**
+ * Parameters used in `colDef.cellRendererParams` to configure a  Group Cell Renderer (`agGroupCellRenderer`).
+ */
+export interface IGroupCellRendererParams<TData = any, TValue = any> {
+    /** Set to `true` to not include any padding (indentation) in the child rows. */
+    suppressPadding?: boolean;
+    /** Set to `true` to suppress expand on double click. */
+    suppressDoubleClickExpand?: boolean;
+    /** Set to `true` to suppress expand on <kbd>↵ Enter</kbd> */
+    suppressEnterExpand?: boolean;
+    /** The value getter for the total row text. Can be a function or expression. */
+    totalValueGetter?: string | TotalValueGetterFunc;
+    /** If `true`, count is not displayed beside the name. */
+    suppressCount?: boolean;
+    /**
+     * Set to `true`, or a function that returns `true`, if a checkbox should be included.
+     *
+     * @deprecated v33 Use `rowSelection.checkboxes` and `rowSelection.checkboxLocation` instead.
+     */
+    checkbox?: boolean | GroupCheckboxSelectionCallback<TData, TValue>;
+    /** The renderer to use for inside the cell (after grouping functions are added) */
+    innerRenderer?: any;
+    /** Additional params to customise to the `innerRenderer`. */
+    innerRendererParams?: any;
+    /** Callback to enable different innerRenderers to be used based of value of params. */
+    innerRendererSelector?: CellRendererSelectorFunc;
+}
+export interface IGroupCellRendererFullRowParams {
+    /**
+     * Only when in fullWidth, this gives whether the comp is pinned or not.
+     * If not doing fullWidth, then this is not provided, as pinned can be got from the column.
+     */
+    pinned?: 'left' | 'right' | null;
+    /** 'true' if comp is showing full width. */
+    fullWidth: boolean;
+    rowDrag?: boolean;
+}
+/**
+ * Parameters provided by the grid to the `init` method of a `agGroupCellRenderer`.
+ * Do not use in `colDef.cellRendererParams` - see `IGroupCellRendererParams` instead.
+ */
+export type GroupCellRendererParams<TData = any, TValue = any> = IGroupCellRendererParams & ICellRendererParams<TData, TValue> & IGroupCellRendererFullRowParams;
+export interface IGroupCellRenderer {
+    setInnerRenderer(compDetails: UserCompDetails | undefined, valueToDisplay: any): void;
+    setChildCount(count: string): void;
+    setCheckboxVisible(value: boolean): void;
+    setExpandedDisplayed(value: boolean): void;
+    setContractedDisplayed(value: boolean): void;
+    addOrRemoveCssClass(cssClassName: string, on: boolean): void;
+}
+export interface IGroupCellRendererCtrl {
+    init(comp: IGroupCellRenderer, eGui: HTMLElement, eCheckbox: HTMLElement, eExpanded: HTMLElement, eContracted: HTMLElement, compClass: any, params: GroupCellRendererParams): void;
+    destroy(): void;
+    getCellAriaRole(): string;
+}

package/dist/types/src/interfaces/iAggColumnNameService.d.ts

@@ -0,0 +1,4 @@
+import type { AgColumn } from '../entities/agColumn';
+export interface IAggColumnNameService {
+    getHeaderName(column: AgColumn, headerName: string | null): string | null;
+}

package/dist/types/src/interfaces/iAutoColService.d.ts

@@ -0,0 +1,11 @@
+import type { ColKey, ColumnCollections } from '../columns/columnModel';
+import type { AgColumn } from '../entities/agColumn';
+import type { ColumnEventType } from '../events';
+export interface IAutoColService {
+    autoCols: ColumnCollections | null;
+    addAutoCols(cols: ColumnCollections): void;
+    createAutoCols(cols: ColumnCollections, updateOrders: (callback: (cols: AgColumn[] | null) => AgColumn[] | null) => void): void;
+    updateAutoCols(source: ColumnEventType): void;
+    getAutoCol(key: ColKey): AgColumn | null;
+    getAutoCols(): AgColumn[] | null;
+}

package/dist/types/src/interfaces/iCallbackParams.d.ts

@@ -0,0 +1,236 @@
+import type { CellPosition } from './iCellPosition';
+import type { ChartToolbarMenuItemOptions, DefaultChartMenuItem } from './iChartOptions';
+import type { Column, ProvidedColumnGroup } from './iColumn';
+import type { AgGridCommon } from './iCommon';
+import type { HeaderPosition } from './iHeaderPosition';
+import type { IRowNode, RowPinnedType } from './iRowNode';
+import type { DefaultMenuItem } from './menuItem';
+import type { ServerSideTransaction } from './serverSideTransaction';
+export interface GetContextMenuItemsParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    /** Names of the items that would be provided by default. */
+    defaultItems: DefaultMenuItem[] | undefined;
+    /** The column, if a cell was clicked, otherwise null. */
+    column: Column | null;
+    /** The row node, if a cell was clicked, otherwise null. */
+    node: IRowNode<TData> | null;
+    /** The value, if a cell was clicked, otherwise null.  */
+    value: any;
+    /** The ContextMenu event that triggered the creation of the Context Menu */
+    event: MouseEvent | Touch;
+}
+export interface GetMainMenuItemsParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    /** The column that was clicked. Will be `null` if clicking on a column group or empty header space. */
+    column: Column | null;
+    /** The column group that was clicked. Will be `null` if clicking on a column or empty header space. */
+    columnGroup: ProvidedColumnGroup | null;
+    /** List of the items that would be displayed by default */
+    defaultItems: DefaultMenuItem[];
+}
+export interface GetChartMenuItemsParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    /** List of the items that would be displayed by default */
+    defaultItems: DefaultChartMenuItem[];
+}
+export interface ProcessUnpinnedColumnsParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    columns: Column[];
+    viewportWidth: number;
+}
+export interface PostProcessPopupParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    /** If popup is for a column, this gives the Column */
+    column?: Column | null;
+    /** If popup is for a row, this gives the RowNode */
+    rowNode?: IRowNode<TData> | null;
+    /** The popup we are showing */
+    ePopup: HTMLElement;
+    /**
+     * The different types are:
+     * 'contextMenu', 'columnMenu', 'aggFuncSelect', 'popupCellEditor', 'chart',
+     * 'advancedFilterBuilder', 'colorPicker', 'columnChooser', 'subMenu'
+     */
+    type: string;
+    /** If the popup is as a result of a button click (eg menu button),
+     *  this is the component that the user clicked */
+    eventSource?: HTMLElement | null;
+    /** If the popup is as a result of a click or touch,
+     *  this is the event - eg user showing context menu */
+    mouseEvent?: MouseEvent | Touch | null;
+}
+export interface SendToClipboardParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    data: string;
+}
+export interface ProcessDataFromClipboardParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    /** 2D array of all cells from the clipboard */
+    data: string[][];
+}
+export interface GetChartToolbarItemsParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    defaultItems?: ChartToolbarMenuItemOptions[];
+}
+export interface FocusGridInnerElementParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    /** This will be true if the focus is coming from and element below the grid in the DOM structure. */
+    fromBottom: boolean;
+}
+export interface NavigateToNextHeaderParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    /** The key for the arrow key pressed,
+     *  left = 'ArrowLeft', up = 'ArrowUp', right = 'ArrowRight', down = 'ArrowDown' */
+    key: string;
+    /** The header that currently has focus */
+    previousHeaderPosition: HeaderPosition | null;
+    /** The header the grid would normally pick as the next header for this navigation */
+    nextHeaderPosition: HeaderPosition | null;
+    /** The number of header rows present in the grid */
+    headerRowCount: number;
+    event: KeyboardEvent;
+}
+export interface TabToNextHeaderParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    /** True if the Shift key is also down */
+    backwards: boolean;
+    /** The header that currently has focus */
+    previousHeaderPosition: HeaderPosition | null;
+    /** The header the grid would normally pick as the next header for this navigation */
+    nextHeaderPosition: HeaderPosition | null;
+    /** The number of header rows present in the grid */
+    headerRowCount: number;
+}
+export interface TabToNextCellParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    /** True if the Shift key is also down */
+    backwards: boolean;
+    /** True if the current cell is editing
+     * (you may want to skip cells that are not editable, as the grid will enter the next cell in editing mode also if tabbing) */
+    editing: boolean;
+    /** The cell that currently has focus */
+    previousCellPosition: CellPosition;
+    /** The cell the grid would normally pick as the next cell for navigation.  */
+    nextCellPosition: CellPosition | null;
+}
+export interface NavigateToNextCellParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    /** The keycode for the arrow key pressed:
+     *  left = 'ArrowLeft', up = 'ArrowUp', right = 'ArrowRight', down = 'ArrowDown' */
+    key: string;
+    /** The cell that currently has focus */
+    previousCellPosition: CellPosition;
+    /** The cell the grid would normally pick as the next cell for navigation */
+    nextCellPosition: CellPosition | null;
+    event: KeyboardEvent | null;
+}
+export interface PaginationNumberFormatterParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    value: number;
+}
+export interface IsGroupOpenByDefaultParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    /** The row node being considered. */
+    rowNode: IRowNode<TData>;
+    /** The Column for which this row is grouping. */
+    rowGroupColumn: Column;
+    /** Same as `rowNode.level` - what level the group is at, e.g. 0 for top level, 1 for second etc */
+    level: number;
+    /** Same as `rowNode.field` - the field we are grouping on, e.g. 'country' */
+    field: string;
+    /** Same as `rowNode.key`, the value of this group, e.g. 'Ireland' */
+    key: string;
+}
+export interface GetServerSideGroupLevelParamsParams extends AgGridCommon<any, any> {
+    /** The level of the store. Top level is 0. */
+    level: number;
+    /** The Row Node for the group that got expanded, or undefined if top level (ie no parent) */
+    parentRowNode?: IRowNode;
+    /** Active Row Group Columns, if any. */
+    rowGroupColumns: Column[];
+    /** Active Pivot Columns, if any. */
+    pivotColumns: Column[];
+    /** true if pivot mode is active. */
+    pivotMode: boolean;
+}
+export interface IsServerSideGroupOpenByDefaultParams extends AgGridCommon<any, any> {
+    data: any;
+    rowNode: IRowNode;
+}
+export interface IsApplyServerSideTransactionParams extends AgGridCommon<any, any> {
+    /** The transaction getting applied. */
+    transaction: ServerSideTransaction;
+    /** The parent RowNode, if transaction is applied to a group. */
+    parentNode: IRowNode;
+    /** Store info, if any, as passed via the success() callback when loading data. */
+    groupLevelInfo: any;
+}
+export interface GetRowIdParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    /** The data item provided to the grid for the row in question */
+    data: TData;
+    /** Pinned state of the row */
+    rowPinned?: RowPinnedType;
+    /** If grouping, the level, ie how many levels from the top. Used by ServerSide Row Model only */
+    level: number;
+    /** If grouping, provides the keys of the parent groups. Used by ServerSide Row Model only */
+    parentKeys?: string[];
+}
+export type RenderedRowEvent = 'virtualRowRemoved';
+export interface ProcessRowParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    eRow: HTMLElement;
+    ePinnedLeftRow?: HTMLElement;
+    ePinnedRightRow?: HTMLElement;
+    rowIndex: number;
+    node: IRowNode<TData>;
+    addRenderedRowListener: (eventType: RenderedRowEvent, listener: (...args: any[]) => any) => void;
+}
+export interface FillOperationParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    /** The mouse event for the fill operation. */
+    event: MouseEvent;
+    /** The values that have been processed by the fill operation. */
+    values: any[];
+    /** The RowNode of the current cell being changed. */
+    rowNode: IRowNode<TData>;
+    /** The Column of the current cell being changed. */
+    column: Column;
+    /** The values that were present before processing started. */
+    initialValues: any[];
+    /** The values that were present before processing, without the aggregation function. */
+    initialNonAggregatedValues: any[];
+    /** The values that were present before processing, after being formatted by their value formatter */
+    initialFormattedValues: any[];
+    /** The index of the current processed value. */
+    currentIndex: number;
+    /** The value of the cell being currently processed by the Fill Operation. */
+    currentCellValue: any;
+    /** The direction of the Fill Operation. */
+    direction: 'up' | 'down' | 'left' | 'right';
+}
+export interface RowHeightParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    /** The data associated with this row from rowData. Data is `undefined` for row groups. */
+    data: TData | undefined;
+    /** The RowNode of the row in question. */
+    node: IRowNode<TData>;
+}
+export interface IsExternalFilterPresentParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+}
+export interface InitialGroupOrderComparatorParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    nodeA: IRowNode<TData>;
+    nodeB: IRowNode<TData>;
+}
+export interface GetGroupRowAggParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    nodes: IRowNode<TData>[];
+}
+export interface PostSortRowsParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    nodes: IRowNode<TData>[];
+}
+export interface IsFullWidthRowParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    rowNode: IRowNode<TData>;
+}
+export interface GetLocaleTextParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    key: string;
+    defaultValue: string;
+    variableValues?: string[];
+}
+export interface GetGroupAggFilteringParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    node: IRowNode<TData>;
+}
+export interface GetGroupIncludeFooterParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    node: IRowNode<TData>;
+}
+export interface GetGroupIncludeTotalRowParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    node: IRowNode<TData>;
+}
+export interface IMenuActionParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    /** The column, if a cell was clicked, otherwise null. */
+    column: Column | null;
+    /** The row node, if a cell was clicked, otherwise null. */
+    node: IRowNode<TData> | null;
+    /** The value, if a cell was clicked, otherwise null.  */
+    value: any;
+}