ag-grid-community 32.3.2 → 33.0.0

package/dist/types/core/interfaces/iFilter.d.ts

@@ -1,186 +0,0 @@
-import type { ColDef, ValueGetterFunc } from '../entities/colDef';
-import type { IFloatingFilterComp } from '../filter/floating/floatingFilter';
-import type { Column } from '../interfaces/iColumn';
-import type { AgPromise } from '../utils/promise';
-import type { IAfterGuiAttachedParams } from './iAfterGuiAttachedParams';
-import type { AgGridCommon } from './iCommon';
-import type { IComponent } from './iComponent';
-import type { IRowModel } from './iRowModel';
-import type { IRowNode } from './iRowNode';
-export type IFilterType = string | {
-    new (): IFilterComp;
-} | boolean;
-export type IFloatingFilterType = string | {
-    new (): IFloatingFilterComp;
-};
-export interface IFilterDef {
-    /**
-     * Filter component to use for this column.
-     * - Set to `true` to use the default filter.
-     * - Set to the name of a provided filter: `agNumberColumnFilter`, `agTextColumnFilter`, `agDateColumnFilter`, `agMultiColumnFilter`, `agSetColumnFilter`.
-     * - Set to a `IFilterComp`.
-     */
-    filter?: any;
-    /** Params to be passed to the filter component specified in `filter`. */
-    filterParams?: any;
-    /**
-     * The custom component to be used for rendering the floating filter.
-     * If none is specified the default AG Grid is used.
-     */
-    floatingFilterComponent?: any;
-    /** Params to be passed to `floatingFilterComponent`. */
-    floatingFilterComponentParams?: any;
-}
-export interface BaseFilter {
-    /**
-     * The grid will ask each active filter, in turn, whether each row in the grid passes. If any
-     * filter fails, then the row will be excluded from the final set. The method is provided a
-     * params object with attributes node (the rodNode the grid creates that wraps the data) and data
-     * (the data object that you provided to the grid for that row). Note that this is only called for the
-     * Client-Side Row Model, and can just return `true` if being used exclusively with other row models.
-     */
-    doesFilterPass(params: IDoesFilterPassParams): boolean;
-    /**
-     * Optional: Gets called when new rows are inserted into the grid. If the filter needs to change its
-     * state after rows are loaded, it can do it here. For example the set filters uses this
-     * to update the list of available values to select from (e.g. 'Ireland', 'UK' etc for
-     * Country filter). To get the list of available values from within this method from the
-     * Client Side Row Model, use `gridApi.forEachLeafNode(callback)`.
-     */
-    onNewRowsLoaded?(): void;
-    /** Optional: Called whenever any filter is changed. */
-    onAnyFilterChanged?(): void;
-    /**
-     * Optional: Used by AG Grid when rendering floating filters and there isn't a floating filter
-     * associated for this filter, this will happen if you create a custom filter and NOT a custom floating
-     * filter.
-     */
-    getModelAsString?(model: any): string;
-    /**
-     * Optional: A hook to perform any necessary operation just after the GUI for this component has been rendered on the screen.
-     * If a parent popup is closed and reopened (e.g. for filters), this method is called each time the component is shown.
-     * This is useful for any logic that requires attachment before executing, such as putting focus on a particular DOM element.
-     */
-    afterGuiAttached?(params?: IAfterGuiAttachedParams): void;
-    /**
-     * Optional: A hook to perform any necessary operation just after the GUI for this component has been removed from the screen.
-     * If a parent popup is opened and closed (e.g. for filters), this method is called each time the component is hidden.
-     * This is useful for any logic to reset the UI state back to the model before the component is reopened.
-     */
-    afterGuiDetached?(): void;
-}
-export interface IFilter extends BaseFilter {
-    /**
-     * Returns `true` if the filter is currently active, otherwise `false`.
-     * If active then 1) the grid will show the filter icon in the column header
-     * and 2) the filter will be included in the filtering of the data.
-     */
-    isFilterActive(): boolean;
-    /**
-     * Returns a model representing the current state of the filter, or `null` if the filter is
-     * not active. The grid calls `getModel()` on all active filters when `gridApi.getFilterModel()` is called.
-     */
-    getModel(): any;
-    /**
-     * Sets the state of the filter using the supplied model. Providing `null` as the model will
-     * de-activate the filter.
-     */
-    setModel(model: any): void | AgPromise<void>;
-    /**
-     * This method is called when the filter parameters change.
-     * The result returned by this method will determine if the filter should be refreshed and reused,
-     * or if a new filter instance should be created.
-     *
-     * This method should return `true` if the filter should be refreshed and reused instead of being destroyed.
-     * This is useful if the new params passed are compatible with the existing filter instance.
-     *
-     * When `false` is returned, the existing filter will be destroyed and a new filter will be created.
-     * This should be done if the new params passed are not compatible with the existing filter instance.
-     *
-     * @param newParams {IFilterParams} - New filter params.
-     *
-     * @returns {boolean} - `true` means that the filter should be refreshed and kept.
-     * `false` means that the filter will be destroyed and a new filter instance will be created.
-     */
-    refresh?(newParams: IFilterParams): boolean;
-}
-export interface ProvidedFilterModel {
-    filterType?: string;
-}
-export interface IFilterComp<TData = any> extends IComponent<IFilterParams<TData>>, IFilter {
-}
-export interface IDoesFilterPassParams<TData = any> {
-    /** The row node in question. */
-    node: IRowNode<TData>;
-    /** The data part of the row node in question. */
-    data: TData;
-}
-export interface IFilterOptionDef {
-    /** A unique key that does not clash with the built-in filter keys. */
-    displayKey: string;
-    /** Display name for the filter. Can be replaced by a locale-specific value using a `localeTextFunc`. */
-    displayName: string;
-    /** Custom filter logic that returns a boolean based on the `filterValues` and `cellValue`. */
-    predicate?: (filterValues: any[], cellValue: any) => boolean;
-    /** Number of inputs to display for this option. Defaults to `1` if unspecified. */
-    numberOfInputs?: 0 | 1 | 2;
-}
-export interface BaseFilterParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
-    /** The column this filter is for. */
-    column: Column;
-    /** The column definition for the column. */
-    colDef: ColDef<TData>;
-    /**
-     * The row model, helpful for looking up data values if needed.
-     * If the filter needs to know which rows are
-     * a) in the table,
-     * b) currently visible (i.e. not already filtered),
-     * c) which groups,
-     * d) what order - all of this can be read from the rowModel.
-     */
-    rowModel: IRowModel;
-    /**
-     * Get the cell value for the given row node and column, which can be the column ID, definition, or `Column` object.
-     * If no column is provided, the column this filter is on will be used.
-     */
-    getValue: <TValue = any>(node: IRowNode<TData>, column?: string | ColDef<TData, TValue> | Column<TValue>) => TValue | null | undefined;
-    /**
-     * A function callback, call with a node to be told whether the node passes all filters except the current filter.
-     * This is useful if you want to only present to the user values that this filter can filter given the status of the other filters.
-     * The set filter uses this to remove from the list,
-     * items that are no longer available due to the state of other filters (like Excel type filtering).
-     */
-    doesRowPassOtherFilter: (rowNode: IRowNode<TData>) => boolean;
-}
-/**
- * Parameters provided by the grid to the `init` method of an `IFilterComp`
- */
-export interface IFilterParams<TData = any, TContext = any> extends BaseFilterParams<TData, TContext> {
-    /**
-     * A function callback to be called when the filter changes. The
-     * grid will then respond by filtering the grid data. The callback
-     * takes one optional parameter which, if included, will get merged
-     * to the FilterChangedEvent object (useful for passing additional
-     * information to anyone listening to this event, however such extra
-     * attributes are not used by the grid).
-     */
-    filterChangedCallback: (additionalEventAttributes?: any) => void;
-    /**
-     * A function callback, to be optionally called, when the filter UI changes.
-     * The grid will respond with emitting a FilterModifiedEvent.
-     * Apart from emitting the event, the grid takes no further action.
-     */
-    filterModifiedCallback: () => void;
-    /**
-     * @deprecated v31 Use `getValue` instead
-     */
-    valueGetter: ValueGetterFunc<TData>;
-}
-/**
- * FilterModel represents the filter state for all columns in the grid keyed by the column id.
- * If using inbuilt AG Grid filters then the type of the column filter model could be one of:
- *      `TextFilterModel`, `NumberFilterModel`, `DateFilterModel`, `SetFilterModel`, `IMultiFilterModel`, `AdvancedFilterModel`
- */
-export interface FilterModel {
-    [colId: string]: any;
-}

package/dist/types/core/interfaces/iFrameworkOverrides.d.ts

@@ -1,48 +0,0 @@
-import type { AgPromise } from '../utils/promise';
-export type FrameworkOverridesIncomingSource = 'resize-observer' | 'ensureVisible' | 'popupPositioning';
-export interface IFrameworkOverrides {
-    setInterval(action: any, interval?: any): AgPromise<number>;
-    addEventListener(element: HTMLElement, type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
-    /**
-     * This method is to cater for Angular's change detection.
-     * Angular uses Zones, we want to run internal AG Grid outside of Zone JS so that we do not kick off
-     * Angular change detection. Any event listener or setTimeout() or setInterval() run by our code
-     * would trigger change detection in Angular.
-     *
-     * Before events are returned to the user, those functions are wrapped in Angular's zone
-     * again so that the user's code triggers change detection as normal. See wrapOutgoing() below.
-     */
-    wrapIncoming: <T>(callback: () => T, source?: FrameworkOverridesIncomingSource) => T;
-    /**
-     * This method is to cater for Angular's change detection.
-     * This is currently used for events that the user provides either via the component or via registration with the grid api.
-     * This method should not be implemented for the other frameworks to avoid unnecessary overhead.
-     */
-    wrapOutgoing: <T>(callback: () => T) => T;
-    /**
-     * The shouldWrapOutgoing property is used to determine if events should be run outside of Angular or not.
-     * If an event handler is registered outside of Angular then we should not wrap the event handler
-     * with runInsideAngular() as the user may not have wanted this.
-     * This is also used to not wrap internal event listeners that are registered with RowNodes and Columns.
-     */
-    shouldWrapOutgoing?: boolean;
-    frameworkComponent(name: string, components?: any): any;
-    isFrameworkComponent(comp: any): boolean;
-    /**
-     * Which rendering engine is used for the grid components. Can be either 'vanilla' or 'react'.
-     */
-    renderingEngine: 'vanilla' | 'react';
-    /**
-     * Returns the framework specific url for linking to a documentation page.
-     * @param path Optional path to append to the base url. i.e 'aligned-grids' Does not need the leading `/`
-     */
-    getDocLink(path?: string): string;
-    /** Used by `RowRenderer` when getting lock. Allows React async refreshes to work. */
-    getLockOnRefresh?(): void;
-    /** Used by `RowRenderer` when releasing lock. Allows React async refreshes to work. */
-    releaseLockOnRefresh?(): void;
-    /** Used by the CtrlsService to decide whether to trigger the whenReady callbacks asynchronously.
-     * Required for React to work with StrictMode from v19 with the current implementation of the CtrlsService.
-     */
-    runWhenReadyAsync?(): boolean;
-}

package/dist/types/core/interfaces/iImmutableService.d.ts

@@ -1,4 +0,0 @@
-export interface IImmutableService {
-    setRowData(data: any[]): void;
-    isActive(): boolean;
-}

package/dist/types/core/interfaces/iInfiniteRowModel.d.ts

@@ -1,8 +0,0 @@
-import type { IDatasource } from './iDatasource';
-import type { IRowModel } from './iRowModel';
-export interface IInfiniteRowModel extends IRowModel {
-    setDatasource(datasource: IDatasource | undefined): void;
-    refreshCache(): void;
-    purgeCache(): void;
-    setRowCount(rowCount: number, maxRowFound?: boolean): void;
-}

package/dist/types/core/interfaces/iModule.d.ts

@@ -1,38 +0,0 @@
-import type { GridApi } from '../api/gridApi';
-import type { ApiFunction, ApiFunctionName } from '../api/iApiFunction';
-import type { ComponentMeta, ControllerMeta, SingletonBean } from '../context/context';
-import type { RowModelType } from './iRowModel';
-export type ModuleValidationValidResult = {
-    isValid: true;
-};
-export type ModuleValidationInvalidResult = {
-    isValid: false;
-    message: string;
-};
-export type ModuleValidationResult = ModuleValidationValidResult | ModuleValidationInvalidResult;
-export interface Module {
-    version: string;
-    /**
-     * Validation run when registering the module
-     *
-     * @return Whether the module is valid or not. If not, a message explaining why it is not valid
-     */
-    validate?: () => ModuleValidationResult;
-    moduleName: string;
-    beans?: SingletonBean[];
-    controllers?: ControllerMeta[];
-    userComponents?: ComponentMeta[];
-    rowModel?: RowModelType;
-    dependantModules?: Module[];
-    apiFunctions?: {
-        [K in ApiFunctionName]: ApiFunction<K>;
-    };
-}
-export declare function _defineModule(definition: Omit<Module, 'apiFunctions'>): Module;
-export declare function _defineModule<TGridApi extends Readonly<Partial<GridApi>>>(definition: Omit<Module, 'apiFunctions'> & (object extends TGridApi ? {
-    apiFunctions: never;
-} : {
-    apiFunctions: {
-        [K in ApiFunctionName & keyof TGridApi]: ApiFunction<K>;
-    };
-})): Module;

package/dist/types/core/interfaces/iRowModel.d.ts

@@ -1,50 +0,0 @@
-import type { RowNode } from '../entities/rowNode';
-export interface RowBounds {
-    rowTop: number;
-    rowHeight: number;
-    rowIndex?: number;
-}
-export type RowModelType = 'infinite' | 'viewport' | 'clientSide' | 'serverSide';
-export interface IRowModel {
-    /** Returns the rowNode at the given index. */
-    getRow(index: number): RowNode | undefined;
-    /** Returns the rowNode for given id. */
-    getRowNode(id: string): RowNode | undefined;
-    /** Returns the number of rows */
-    getRowCount(): number;
-    getTopLevelRowCount(): number;
-    getTopLevelRowDisplayedIndex(topLevelIndex: number): number;
-    /** Returns the row index at the given pixel */
-    getRowIndexAtPixel(pixel: number): number;
-    /** Returns true if the provided rowNode is in the list of rows to render */
-    isRowPresent(rowNode: RowNode): boolean;
-    /** Returns row top and bottom for a given row */
-    getRowBounds(index: number): RowBounds | null;
-    /** Returns true if this model has no rows, regardless of model filter. EG if rows present, but filtered
-     * out, this still returns false. If it returns true, then the grid shows the 'no rows' overlay - but we
-     * don't show that overlay if the rows are just filtered out. */
-    isEmpty(): boolean;
-    /** Returns true if no rows (either no rows at all, or the rows are filtered out). This is what the grid
-     * uses to know if there are rows to render or not. */
-    isRowsToRender(): boolean;
-    /** Returns all rows in range that should be selected. If there is a gap in range (non ClientSideRowModel) then
-     *  then no rows should be returned  */
-    getNodesInRangeForSelection(first: RowNode, last: RowNode): RowNode[];
-    /** Iterate through each node. What this does depends on the model type. For clientSide, goes through
-     * all nodes. For serverSide, goes through what's loaded in memory. */
-    forEachNode(callback: (rowNode: RowNode, index: number) => void, includeFooterNodes?: boolean): void;
-    /** The base class returns the type. We use this instead of 'instanceof' as the client might provide
-     * their own implementation of the models in the future. */
-    getType(): RowModelType;
-    /**
-     * It tells us if this row model knows about the last row that it can produce. This is used by the
-     * PaginationPanel, if last row is not found, then the 'last' button is disabled and the last page is
-     * not shown. This is always true for ClientSideRowModel. It toggles for InfiniteRowModel.
-     */
-    isLastRowIndexKnown(): boolean;
-    /** Used by CSRM only - is makes sure there are now estimated row heights within the range. */
-    ensureRowHeightsValid(startPixel: number, endPixel: number, startLimitIndex: number, endLimitIndex: number): boolean;
-    /** Gets called after grid is initialised. What happens depends on row model. Client Side will take rowData
-     * from gridOptions, the other row models will start calling their datasources. */
-    start(): void;
-}

package/dist/types/core/interfaces/iRowNode.d.ts

@@ -1,279 +0,0 @@
-import type { AgEvent, SelectionEventSourceType } from '../events';
-import type { Column } from '../interfaces/iColumn';
-import type { BuildEventTypeMap } from './iEventEmitter';
-export type RowNodeEventType = 'rowSelected' | 'selectableChanged' | 'displayedChanged' | 'dataChanged' | 'cellChanged' | 'masterChanged' | 'heightChanged' | 'topChanged' | 'groupChanged' | 'allChildrenCountChanged' | 'firstChildChanged' | 'lastChildChanged' | 'childIndexChanged' | 'rowIndexChanged' | 'expandedChanged' | 'hasChildrenChanged' | 'uiLevelChanged' | 'rowHighlightChanged' | 'mouseEnter' | 'mouseLeave' | 'draggingChanged';
-export type RowNodeEventTypeMap<TData = any> = BuildEventTypeMap<RowNodeEventType, {
-    rowSelected: RowNodeSelectedEvent<TData>;
-    selectableChanged: SelectableChangedEvent<TData>;
-    displayedChanged: DisplayedChangedEvent<TData>;
-    dataChanged: DataChangedEvent<TData>;
-    cellChanged: CellChangedEvent<TData>;
-    masterChanged: MasterChangedEvent<TData>;
-    heightChanged: HeightChangedEvent<TData>;
-    topChanged: TopChangedEvent<TData>;
-    groupChanged: GroupChangedEvent<TData>;
-    allChildrenCountChanged: AllChildrenCountChangedEvent<TData>;
-    firstChildChanged: FirstChildChangedEvent<TData>;
-    lastChildChanged: LastChildChangedEvent<TData>;
-    childIndexChanged: ChildIndexChangedEvent<TData>;
-    rowIndexChanged: RowIndexChangedEvent<TData>;
-    expandedChanged: ExpandedChangedEvent<TData>;
-    hasChildrenChanged: HasChildrenChangedEvent<TData>;
-    uiLevelChanged: UiLevelChangedEvent<TData>;
-    rowHighlightChanged: RowHighlightChangedEvent<TData>;
-    mouseEnter: MouseEnterEvent<TData>;
-    mouseLeave: MouseLeaveEvent<TData>;
-    draggingChanged: DraggingChangedEvent<TData>;
-}>;
-export type AgRowNodeEventListener<TEventType extends keyof RowNodeEventTypeMap<TData>, TData = any> = (params: RowNodeEventTypeMap<TData>[TEventType]) => void;
-export interface SetSelectedParams {
-    newValue: boolean;
-    clearSelection?: boolean;
-    suppressFinishActions?: boolean;
-    rangeSelect?: boolean;
-    groupSelectsFiltered?: boolean;
-    source: SelectionEventSourceType;
-}
-export interface RowNodeEvent<T extends RowNodeEventType, TData = any> extends AgEvent<T> {
-    node: IRowNode<TData>;
-}
-export interface RowNodeSelectedEvent<TData = any> extends RowNodeEvent<'rowSelected', TData> {
-}
-export interface MouseEnterEvent<TData = any> extends RowNodeEvent<'mouseEnter', TData> {
-}
-export interface MouseLeaveEvent<TData = any> extends RowNodeEvent<'mouseLeave', TData> {
-}
-export interface HeightChangedEvent<TData = any> extends RowNodeEvent<'heightChanged', TData> {
-}
-export interface RowIndexChangedEvent<TData = any> extends RowNodeEvent<'rowIndexChanged', TData> {
-}
-export interface TopChangedEvent<TData = any> extends RowNodeEvent<'topChanged', TData> {
-}
-export interface ExpandedChangedEvent<TData = any> extends RowNodeEvent<'expandedChanged', TData> {
-}
-export interface FirstChildChangedEvent<TData = any> extends RowNodeEvent<'firstChildChanged', TData> {
-}
-export interface LastChildChangedEvent<TData = any> extends RowNodeEvent<'lastChildChanged', TData> {
-}
-export interface ChildIndexChangedEvent<TData = any> extends RowNodeEvent<'childIndexChanged', TData> {
-}
-export interface AllChildrenCountChangedEvent<TData = any> extends RowNodeEvent<'allChildrenCountChanged', TData> {
-}
-export interface UiLevelChangedEvent<TData = any> extends RowNodeEvent<'uiLevelChanged', TData> {
-}
-export interface DataChangedEvent<TData = any> extends RowNodeEvent<'dataChanged', TData> {
-    oldData: TData | undefined;
-    newData: TData | undefined;
-    update: boolean;
-}
-export interface CellChangedEvent<TData = any> extends RowNodeEvent<'cellChanged', TData> {
-    column: Column;
-    newValue: TData | undefined;
-    oldValue: TData | undefined;
-}
-export interface SelectableChangedEvent<TData = any> extends RowNodeEvent<'selectableChanged', TData> {
-}
-export interface DisplayedChangedEvent<TData = any> extends RowNodeEvent<'displayedChanged', TData> {
-}
-export interface MasterChangedEvent<TData = any> extends RowNodeEvent<'masterChanged', TData> {
-}
-export interface GroupChangedEvent<TData = any> extends RowNodeEvent<'groupChanged', TData> {
-}
-export interface HasChildrenChangedEvent<TData = any> extends RowNodeEvent<'hasChildrenChanged', TData> {
-}
-export interface RowHighlightChangedEvent<TData = any> extends RowNodeEvent<'rowHighlightChanged', TData> {
-}
-export interface DraggingChangedEvent<TData = any> extends RowNodeEvent<'draggingChanged', TData> {
-}
-export declare enum RowHighlightPosition {
-    Above = 0,
-    Below = 1
-}
-export type RowPinnedType = 'top' | 'bottom' | null | undefined;
-export interface VerticalScrollPosition {
-    top: number;
-    bottom: number;
-}
-interface BaseRowNode<TData = any> {
-    /** Unique ID for the node. Either provided by the application, or generated by the grid if not. */
-    id: string | undefined;
-    /**
-     * The data as provided by the application.
-     * Can be `undefined` when using row grouping or during grid initialisation.
-     */
-    data: TData | undefined;
-    /**
-     * This will be `true` if it has a rowIndex assigned, otherwise `false`.
-     */
-    displayed: boolean;
-    /** Either `'top'` or `'bottom'` if row pinned, otherwise `undefined` or `null`. */
-    rowPinned: RowPinnedType;
-    /** Is this row selectable. */
-    selectable: boolean;
-    /** The height, in pixels, of this row. */
-    rowHeight: number | null | undefined;
-    /** The row top position in pixels. */
-    rowTop: number | null;
-    /** `true` if this node is a group node (i.e. it has children) */
-    group: boolean | undefined;
-    /** `true` if this is the first child in this group. Changes when data is sorted. */
-    firstChild: boolean;
-    /** `true` if this is the last child in this group. Changes when data is sorted. */
-    lastChild: boolean;
-    /** Index of this row with respect to its parent when grouping. Changes when data is sorted. */
-    childIndex: number;
-    /** How many levels this node is from the top when grouping. */
-    level: number;
-    /** How many levels this node is from the top when grouping in the UI (only different to `parent` when `groupRemoveSingleChildren=true`).*/
-    uiLevel: number;
-    /** The parent node to this node, or empty if top level. */
-    parent: IRowNode<TData> | null;
-    /** Used by server-side row model. `true` if this row node is a stub. A stub is a placeholder row with loading icon while waiting from row to be loaded. */
-    stub: boolean | undefined;
-    /** Used by server side row model, `true` if this row node failed a load. */
-    failedLoad: boolean | undefined;
-    /**
-     * The index of the row in the source rowData array including any updates via transactions.
-     * It does not change when sorting, filtering, grouping, pivoting or any other UI related operations.
-     * If this is a filler node (a visual row created by AG Grid in tree data or grouping) the value will be `-1`.
-     */
-    readonly sourceRowIndex: number;
-    /** The current row index. If the row is filtered out or in a collapsed group, this value will be `null`. */
-    rowIndex: number | null;
-    /** If using quick filter, stores a string representation of the row for searching against. */
-    quickFilterAggregateText: string | null;
-    /** `true` if this row is a master row, part of master / detail (ie row can be expanded to show detail). */
-    master: boolean;
-    /** `true` if this row is a detail row, part of master / detail (ie child row of an expanded master row). */
-    detail: boolean | undefined;
-}
-interface GroupRowNode<TData = any> {
-    /** The field we are grouping on from our row data. */
-    field: string | null;
-    /** The key value for this group. */
-    key: string | null;
-    /** If using row grouping, contains the group values for this group. */
-    groupData: {
-        [key: string]: any | null;
-    } | null;
-    /** If using row grouping and aggregation, contains the aggregation data. */
-    aggData: any;
-    /** The row group column used for this group. */
-    rowGroupColumn: Column | null;
-    /**
-     * If doing in-memory (client-side) grouping, this is the index of the group column this cell is for.
-     * This will always be the same as the level, unless we are collapsing groups, i.e. `groupRemoveSingleChildren=true`.
-     */
-    rowGroupIndex: number | null;
-    /** `true` if group is expanded, otherwise `false`. */
-    expanded: boolean;
-    /** `true` if this node is a group and the group is the bottom level in the tree. */
-    leafGroup: boolean | undefined;
-    /** All lowest level nodes beneath this node, no groups. */
-    allLeafChildren: IRowNode<TData>[] | null;
-    /** Number of children and grand children. */
-    allChildrenCount: number | null;
-    /** Children of this group. If multi levels of grouping, shows only immediate children. */
-    childrenAfterGroup: IRowNode<TData>[] | null;
-    /** Sorted children of this group. */
-    childrenAfterSort: IRowNode<TData>[] | null;
-    /** Filtered children of this group. */
-    childrenAfterFilter: IRowNode<TData>[] | null;
-    /** `true` if row is a footer. Footers have `group = true` and `footer = true`. */
-    footer: boolean | undefined;
-    /** If using footers, reference to the footer node for this group. */
-    sibling: IRowNode<TData>;
-}
-export interface IRowNode<TData = any> extends BaseRowNode<TData>, GroupRowNode<TData> {
-    /**
-     * Select (or deselect) the node.
-     * @param newValue -`true` for selection, `false` for deselection.
-     * @param clearSelection - If selecting, then passing `true` will select the node exclusively (i.e. NOT do multi select). If doing deselection, `clearSelection` has no impact. Default: `false`
-     * @param source - Source property that will appear in the `selectionChanged` event. Default: `'api'`
-     */
-    setSelected(newValue: boolean, clearSelection?: boolean, source?: SelectionEventSourceType): void;
-    /** Returns:
-     * - `true` if node is selected.
-     * - `false` if the node isn't selected.
-     * - `undefined` if it's partially selected (group where not all children are selected).
-     */
-    isSelected(): boolean | undefined;
-    /**
-     * Returns:
-     * - `true` if node is either pinned to the `top` or `bottom`.
-     * - `false` if the node isn't pinned.
-     */
-    isRowPinned(): boolean;
-    /** Returns:
-     * - `true` if the node can be expanded, i.e it is a group or master row.
-     * - `false` if the node cannot be expanded.
-     */
-    isExpandable(): boolean;
-    /**
-     * Set the expanded state of this rowNode.
-     * @param expanded - `true` to expand, `false` to collapse.
-     * @param sourceEvent - Optional event that will be passed to the `rowGroupOpened` event.
-     * @param forceSync - By default rows are expanded asynchronously for best performance. Set to `true` if you need to interact with the expanded row immediately after this function.
-     */
-    setExpanded(expanded: boolean, sourceEvent?: MouseEvent | KeyboardEvent, forceSync?: boolean): void;
-    /**
-     * @deprecated v32.2.0 Check `node.detail` then user provided callback `isFullWidthRow` instead.
-     *
-     * Returns:
-     * - `true` if the node is a full width cell.
-     * - `false` if the node is not a full width cell.
-     */
-    isFullWidthCell(): boolean;
-    /**
-     * Returns:
-     * - `true` if the node is currently hovered.
-     * - `false` if the node is not hovered.
-     */
-    isHovered(): boolean;
-    /** Add an event listener. */
-    addEventListener<T extends RowNodeEventType>(eventType: T, userListener: AgRowNodeEventListener<T>): void;
-    /** Remove event listener. */
-    removeEventListener<T extends RowNodeEventType>(eventType: T, userListener: AgRowNodeEventListener<T>): void;
-    /**
-     * The first time `quickFilter` runs, the grid creates a one-off string representation of the row.
-     * This string is then used for the quick filter instead of hitting each column separately.
-     * When you edit, using grid editing, this string gets cleared down.
-     * However if you edit without using grid editing, you will need to clear this string down for the row to be updated with the new values.
-     * Otherwise new values will not work with the `quickFilter`.
-     */
-    resetQuickFilterAggregateText(): void;
-    /** Perform a depth-first search of this node and its children. */
-    depthFirstSearch(callback: (rowNode: IRowNode<TData>) => void): void;
-    /**
-     * Sets the row height.
-     * Call if you want to change the height initially assigned to the row.
-     * After calling, you must call `api.onRowHeightChanged()` so the grid knows it needs to work out the placement of the rows.
-     * @param rowHeight - new height of the row
-     * @param estimated - is this an estimated height. Default: `false`
-     */
-    setRowHeight(rowHeight: number | undefined | null, estimated?: boolean): void;
-    /**
-     * Replaces the data on the `rowNode`. When this method is called, the grid will refresh the entire rendered row if it is displayed.
-     */
-    setData(data: TData): void;
-    /**
-     * Updates the data on the `rowNode`. When this method is called, the grid will refresh the entire rendered row if it is displayed.
-     */
-    updateData(data: TData): void;
-    /**
-     * Replaces the value on the `rowNode` for the specified column. When complete,
-     * the grid will refresh the rendered cell on the required row only.
-     * **Note**: This method only fires `onCellEditRequest` when the Grid is in **Read Only** mode.
-     *
-     * @param colKey The column where the value should be updated
-     * @param newValue The new value
-     * @param eventSource The source of the event
-     * @returns `true` if the value was changed, otherwise `false`.
-     */
-    setDataValue(colKey: string | Column, newValue: any, eventSource?: string): boolean;
-    /**
-     * Returns the route of the row node. If the Row Node does not have a key (i.e it's a group) returns undefined
-     */
-    getRoute(): string[] | undefined;
-}
-export {};

package/dist/types/core/interfaces/iRowNodeStage.d.ts

@@ -1,14 +0,0 @@
-import type { RowNode } from '../entities/rowNode';
-import type { ChangedPath } from '../utils/changedPath';
-import type { RowNodeTransaction } from './rowNodeTransaction';
-export interface StageExecuteParams<TData = any> {
-    rowNode: RowNode<TData>;
-    rowNodeTransaction?: RowNodeTransaction<TData> | null;
-    rowNodeTransactions?: RowNodeTransaction<TData>[] | null;
-    rowNodesOrderChanged?: boolean;
-    changedPath?: ChangedPath;
-    afterColumnsChanged?: boolean;
-}
-export interface IRowNodeStage<TData = any> {
-    execute(params: StageExecuteParams<TData>): any;
-}