ag-grid-community 32.0.2 → 32.2.0

package/dist/types/core/focusService.d.ts

@@ -25,6 +25,7 @@ export declare class FocusService extends BeanStub implements NamedBean {
     private navigationService;
     private ctrlsService;
     private filterManager?;
+    private overlayService;
     private rangeService?;
     private advancedFilterService?;
     wireBeans(beans: BeanCollection): void;
@@ -36,10 +37,10 @@ export declare class FocusService extends BeanStub implements NamedBean {
     private advancedFilterFocusColumn;
     private static keyboardModeActive;
     private static instanceCount;
+    private awaitRestoreFocusedCell;
     private static addKeyboardModeEvents;
     private static removeKeyboardModeEvents;
     private static toggleKeyboardMode;
-    private static unregisterGridCompController;
     postConstruct(): void;
     private registerKeyboardFocusEvents;
     onColumnEverythingChanged(): void;
@@ -49,6 +50,8 @@ export declare class FocusService extends BeanStub implements NamedBean {
     private isDomDataMissingInHierarchy;
     getFocusedCell(): CellPosition | null;
     shouldRestoreFocus(cell: CellPosition): boolean;
+    clearRestoreFocus(): void;
+    restoreFocusedCell(cellPosition: CellPosition, setFocusCallback: () => void): void;
     private isCellRestoreFocused;
     setRestoreFocusedCell(cellPosition: CellPosition): void;
     private getFocusEventParams;
@@ -60,6 +63,8 @@ export declare class FocusService extends BeanStub implements NamedBean {
     clearFocusedHeader(): void;
     getFocusedHeader(): HeaderPosition | null;
     setFocusedHeader(headerRowIndex: number, column: AgColumnGroup | AgColumn): void;
+    isHeaderFocusSuppressed(): boolean;
+    isCellFocusSuppressed(): boolean;
     focusHeaderPosition(params: {
         headerPosition: HeaderPosition | null;
         direction?: 'Before' | 'After' | null;
@@ -88,7 +93,11 @@ export declare class FocusService extends BeanStub implements NamedBean {
     findNextFocusableElement(rootNode?: HTMLElement, onlyManaged?: boolean | null, backwards?: boolean): HTMLElement | null;
     isTargetUnderManagedComponent(rootNode: HTMLElement, target?: HTMLElement): boolean;
     findTabbableParent(node: HTMLElement | null, limit?: number): HTMLElement | null;
-    focusGridView(column?: AgColumn, backwards?: boolean): boolean;
+    focusOverlay(backwards?: boolean): boolean;
+    private focusGridViewFailed;
+    focusGridView(column?: AgColumn, backwards?: boolean, canFocusOverlay?: boolean): boolean;
+    /** Returns true if an element inside the grid has focus */
+    isGridFocused(): boolean;
     focusNextGridCoreContainer(backwards: boolean, forceOut?: boolean): boolean;
     private focusAdvancedFilter;
     focusNextFromAdvancedFilter(backwards?: boolean, forceFirstColumn?: boolean): boolean;
@@ -96,4 +105,5 @@ export declare class FocusService extends BeanStub implements NamedBean {
     addFocusableContainer(container: FocusableContainer): void;
     removeFocusableContainer(container: FocusableContainer): void;
     focusGridInnerElement(fromBottom?: boolean): boolean;
+    allowFocusForNextGridCoreContainer(up?: boolean): void;
 }

package/dist/types/core/grid.d.ts

@@ -21,12 +21,21 @@ export interface Params {
      */
     modules?: Module[];
 }
+/**
+ * When providing global grid options, specify how they should be merged with the grid options provided to individual grids.
+ * - `deep` will merge the global options into the provided options deeply, with provided options taking precedence.
+ * - `shallow` will merge the global options with the provided options shallowly, with provided options taking precedence.
+ * @default 'shallow'
+ * @param gridOptions - global grid options
+ */
+export type GlobalGridOptionsMergeStrategy = 'deep' | 'shallow';
 /**
  * Provide gridOptions that will be shared by all grid instances.
  * Individually defined GridOptions will take precedence over global options.
  * @param gridOptions - global grid options
  */
-export declare function provideGlobalGridOptions(gridOptions: GridOptions): void;
+export declare function provideGlobalGridOptions(gridOptions: GridOptions, mergeStrategy?: GlobalGridOptionsMergeStrategy): void;
+export declare function _getGlobalGridOption<K extends keyof GridOptions>(gridOption: K): GridOptions[K];
 /**
  * Creates a grid inside the provided HTML element.
  * @param eGridDiv Parent element to contain the grid.

package/dist/types/core/gridBodyComp/abstractFakeScrollComp.d.ts

@@ -1,6 +1,7 @@
 import type { BeanCollection } from '../context/context';
 import { Component } from '../widgets/component';
-export declare abstract class AbstractFakeScrollComp extends Component {
+import type { ScrollPartner } from './gridBodyScrollFeature';
+export declare abstract class AbstractFakeScrollComp extends Component implements ScrollPartner {
     private readonly direction;
     private animationFrameService;
     wireBeans(beans: BeanCollection): void;
@@ -18,7 +19,7 @@ export declare abstract class AbstractFakeScrollComp extends Component {
     protected onScrollVisibilityChanged(): void;
     protected hideAndShowInvisibleScrollAsNeeded(): void;
     protected attemptSettingScrollPosition(value: number): void;
-    protected getViewport(): HTMLElement;
+    getViewportElement(): HTMLElement;
     getContainer(): HTMLElement;
     onScrollCallback(fn: () => void): void;
 }

package/dist/types/core/gridBodyComp/gridBodyCtrl.d.ts

@@ -51,6 +51,10 @@ export declare class GridBodyCtrl extends BeanStub {
     private eTop;
     private eBottom;
     private eStickyTop;
+    private eCenterColsViewport;
+    private eFullWidthContainer;
+    private eStickyTopFullWidthContainer;
+    private eStickyBottomFullWidthContainer;
     private stickyTopHeight;
     private eStickyBottom;
     private stickyBottomHeight;
@@ -65,6 +69,8 @@ export declare class GridBodyCtrl extends BeanStub {
     setColumnMovingCss(moving: boolean): void;
     setCellTextSelection(selectable?: boolean): void;
     private onScrollVisibilityChanged;
+    private onScrollGapChanged;
+    private updateScrollingClasses;
     private onGridColumnsChanged;
     private disableBrowserDragging;
     private addStopEditingWhenGridLosesFocus;
@@ -77,10 +83,11 @@ export declare class GridBodyCtrl extends BeanStub {
     private addBodyViewportListener;
     private addFullWidthContainerWheelListener;
     private onFullWidthContainerWheel;
+    private onStickyWheel;
+    private scrollGridBodyToMatchEvent;
     private onBodyViewportContextMenu;
     private mockContextMenuForIPad;
     private onBodyViewportWheel;
-    private onStickyWheel;
     getGui(): HTMLElement;
     scrollVertically(pixels: number): number;
     private addRowDragListener;

package/dist/types/core/gridBodyComp/gridBodyScrollFeature.d.ts

@@ -1,6 +1,10 @@
 import { BeanStub } from '../context/beanStub';
 import type { BeanCollection } from '../context/context';
 import type { IRowNode, VerticalScrollPosition } from '../interfaces/iRowNode';
+export interface ScrollPartner {
+    getViewportElement(): HTMLElement;
+    onScrollCallback(fn: () => void): void;
+}
 export declare class GridBodyScrollFeature extends BeanStub {
     private ctrlsService;
     private animationFrameService;
@@ -27,15 +31,16 @@ export declare class GridBodyScrollFeature extends BeanStub {
     constructor(eBodyViewport: HTMLElement);
     postConstruct(): void;
     private addScrollListener;
+    private addHorizontalScrollListeners;
+    private addVerticalScrollListeners;
+    private registerScrollPartner;
     private onDisplayedColumnsWidthChanged;
-    horizontallyScrollHeaderCenterAndFloatingCenter(scrollLeft?: number): void;
+    private horizontallyScrollHeaderCenterAndFloatingCenter;
+    private setScrollLeftForAllContainersExceptCurrent;
+    private getViewportForSource;
     private isControllingScroll;
-    private onFakeHScroll;
     private onHScroll;
-    private onHScrollCommon;
-    private onFakeVScroll;
     private onVScroll;
-    private onVScrollCommon;
     private doHorizontalScroll;
     private fireScrollEvent;
     private shouldBlockScrollUpdate;

package/dist/types/core/gridBodyComp/navigationService.d.ts

@@ -2,6 +2,7 @@ import type { NamedBean } from '../context/bean';
 import { BeanStub } from '../context/beanStub';
 import type { BeanCollection } from '../context/context';
 import type { CellPosition } from '../entities/cellPositionUtils';
+import type { RowPosition } from '../entities/rowPositionUtils';
 import { CellCtrl } from '../rendering/cell/cellCtrl';
 import { RowCtrl } from '../rendering/row/rowCtrl';
 export declare class NavigationService extends BeanStub implements NamedBean {
@@ -18,6 +19,7 @@ export declare class NavigationService extends BeanStub implements NamedBean {
     private rowPositionUtils;
     private cellNavigationService;
     private pinnedRowModel;
+    private scrollVisibleService;
     private rangeService?;
     wireBeans(beans: BeanCollection): void;
     private gridBodyCon;
@@ -51,7 +53,7 @@ export declare class NavigationService extends BeanStub implements NamedBean {
     private lookupRowNodeForCell;
     navigateToNextCell(event: KeyboardEvent | null, key: string, currentCell: CellPosition, allowUserOverride: boolean): void;
     private getNormalisedPosition;
-    private tryToFocusFullWidthRow;
+    tryToFocusFullWidthRow(position: CellPosition | RowPosition, backwards?: boolean): boolean;
     private focusPosition;
     private isValidNavigateCell;
     private getLastCellOfColSpan;

package/dist/types/core/gridBodyComp/rowContainer/rowContainerCtrl.d.ts

@@ -3,6 +3,7 @@ import type { BeanCollection } from '../../context/context';
 import type { ColumnPinnedType } from '../../interfaces/iColumn';
 import type { RowCtrl } from '../../rendering/row/rowCtrl';
 import type { RowRenderer } from '../../rendering/rowRenderer';
+import type { ScrollPartner } from '../gridBodyScrollFeature';
 import { ViewportSizeFeature } from '../viewportSizeFeature';
 export type RowContainerName = 'left' | 'right' | 'center' | 'fullWidth' | 'topLeft' | 'topRight' | 'topCenter' | 'topFullWidth' | 'stickyTopLeft' | 'stickyTopRight' | 'stickyTopCenter' | 'stickyTopFullWidth' | 'stickyBottomLeft' | 'stickyBottomRight' | 'stickyBottomCenter' | 'stickyBottomFullWidth' | 'bottomLeft' | 'bottomRight' | 'bottomCenter' | 'bottomFullWidth';
 export type RowContainerType = 'left' | 'right' | 'center' | 'fullWidth';
@@ -18,6 +19,7 @@ export type RowContainerOptions = {
 export declare function _getRowContainerOptions(name: RowContainerName): RowContainerOptions;
 export interface IRowContainerComp {
     setViewportHeight(height: string): void;
+    setHorizontalScroll(offset: number): void;
     setRowCtrls(params: {
         rowCtrls: RowCtrl[];
         useFlushSync?: boolean;
@@ -26,7 +28,7 @@ export interface IRowContainerComp {
     setContainerWidth(width: string): void;
     setOffsetTop(offset: string): void;
 }
-export declare class RowContainerCtrl extends BeanStub {
+export declare class RowContainerCtrl extends BeanStub implements ScrollPartner {
     private dragService;
     private ctrlsService;
     private columnViewportService;
@@ -51,13 +53,15 @@ export declare class RowContainerCtrl extends BeanStub {
     getContainerElement(): HTMLElement;
     getViewportSizeFeature(): ViewportSizeFeature | undefined;
     setComp(view: IRowContainerComp, eContainer: HTMLElement, eViewport: HTMLElement): void;
+    onScrollCallback(fn: () => void): void;
     private addListeners;
     private listenOnDomOrder;
-    private stopHScrollOnPinnedRows;
     onDisplayedColumnsChanged(): void;
     private onDisplayedColumnsWidthChanged;
     private addPreventScrollWhileDragging;
     onHorizontalViewportChanged(afterScroll?: boolean): void;
+    hasHorizontalScrollGap(): boolean;
+    hasVerticalScrollGap(): boolean;
     getCenterWidth(): number;
     getCenterViewportScrollLeft(): number;
     registerViewportResizeListener(listener: () => void): void;
@@ -65,7 +69,7 @@ export declare class RowContainerCtrl extends BeanStub {
     getViewportScrollLeft(): number;
     isHorizontalScrollShowing(): boolean;
     getViewportElement(): HTMLElement;
-    setContainerTranslateX(amount: number): void;
+    setHorizontalScroll(offset: number): void;
     getHScrollPosition(): {
         left: number;
         right: number;

package/dist/types/core/gridBodyComp/rowDragFeature.d.ts

@@ -2,7 +2,7 @@ import { BeanStub } from '../context/beanStub';
 import type { BeanCollection } from '../context/context';
 import type { DragAndDropIcon, DraggingEvent, DropTarget } from '../dragAndDrop/dragAndDropService';
 import { DragSourceType } from '../dragAndDrop/dragAndDropService';
-import type { RowDragEndEvent, RowDragEnterEvent, RowDragLeaveEvent, RowDragMoveEvent } from '../events';
+import type { RowDragCancelEvent, RowDragEndEvent, RowDragEnterEvent, RowDragLeaveEvent, RowDragMoveEvent } from '../events';
 export interface RowDropZoneEvents {
     /** Callback function that will be executed when the rowDrag enters the target. */
     onDragEnter?: (params: RowDragEnterEvent) => void;
@@ -15,6 +15,7 @@ export interface RowDropZoneEvents {
     onDragging?: (params: RowDragMoveEvent) => void;
     /** Callback function that will be executed when the rowDrag drops rows within the target. */
     onDragStop?: (params: RowDragEndEvent) => void;
+    onDragCancel?: (params: RowDragCancelEvent) => void;
 }
 export interface RowDropZoneParams extends RowDropZoneEvents {
     /** A callback method that returns the DropZone HTMLElement. */
@@ -47,7 +48,6 @@ export declare class RowDragFeature extends BeanStub implements DropTarget {
     onDragEnter(draggingEvent: DraggingEvent): void;
     onDragging(draggingEvent: DraggingEvent): void;
     private isFromThisGrid;
-    private isDropZoneWithinThisGrid;
     private onEnterOrDragging;
     private doManagedDrag;
     private getRowIndexNumber;
@@ -62,5 +62,6 @@ export declare class RowDragFeature extends BeanStub implements DropTarget {
     private dispatchGridEvent;
     onDragLeave(draggingEvent: DraggingEvent): void;
     onDragStop(draggingEvent: DraggingEvent): void;
+    onDragCancel(draggingEvent: DraggingEvent): void;
     private stopDragging;
 }

package/dist/types/core/gridBodyComp/scrollVisibleService.d.ts

@@ -9,15 +9,23 @@ export declare class ScrollVisibleService extends BeanStub implements NamedBean
     beanName: "scrollVisibleService";
     private ctrlsService;
     private columnAnimationService;
+    private scrollbarWidth;
     wireBeans(beans: BeanCollection): void;
     private horizontalScrollShowing;
     private verticalScrollShowing;
+    private horizontalScrollGap;
+    private verticalScrollGap;
     postConstruct(): void;
     onDisplayedColumnsChanged(): void;
     private onDisplayedColumnsWidthChanged;
-    private update;
-    private updateImpl;
+    onCentreViewportResized(): void;
+    private updateScrollVisible;
+    private updateScrollVisibleImpl;
+    private updateScrollGap;
     setScrollsVisible(params: SetScrollsVisibleParams): void;
     isHorizontalScrollShowing(): boolean;
     isVerticalScrollShowing(): boolean;
+    hasHorizontalScrollGap(): boolean;
+    hasVerticalScrollGap(): boolean;
+    getScrollbarWidth(): number;
 }

package/dist/types/core/gridComp/gridCtrl.d.ts

@@ -5,6 +5,7 @@ import type { LayoutView } from '../styling/layoutFeature';
 import type { ComponentSelector } from '../widgets/component';
 export interface IGridComp extends LayoutView {
     setRtlClass(cssClass: string): void;
+    setGridThemeClass(cssClass: string): void;
     destroyGridUi(): void;
     forceFocusOutOfContainer(up: boolean): void;
     getFocusableContainers(): FocusableContainer[];
@@ -31,7 +32,6 @@ export declare class GridCtrl extends BeanStub {
     isDetailGrid(): boolean;
     getOptionalSelectors(): OptionalGridComponents;
     private onGridSizeChanged;
-    private addRtlSupport;
     destroyGridUi(): void;
     getGui(): HTMLElement;
     setResizeCursor(on: boolean): void;
@@ -41,7 +41,11 @@ export declare class GridCtrl extends BeanStub {
     forceFocusOutOfContainer(up?: boolean): void;
     addFocusableContainer(container: FocusableContainer): void;
     removeFocusableContainer(container: FocusableContainer): void;
+    allowFocusForNextCoreContainer(up?: boolean): void;
+    private getNextFocusableIndex;
     private focusContainer;
     private getFocusableContainers;
+    private updateGridThemeClass;
+    private handleThemeChange;
     destroy(): void;
 }

package/dist/types/core/gridCoreModule.d.ts

@@ -1,13 +1,7 @@
-import type { Module } from './interfaces/iModule';
 import { ModuleNames } from './modules/moduleNames';
-import { ValidationService } from './validation/validationService';
 export declare const GridCoreModule: {
     version: string;
     moduleName: ModuleNames;
 };
-export declare const ValidationsModule: {
-    version: string;
-    moduleName: string;
-    beans: (typeof ValidationService)[];
-};
-export declare const CommunityFeaturesModule: Module;
+export declare const ValidationsModule: import("./interfaces/iModule").Module;
+export declare const CommunityFeaturesModule: import("./interfaces/iModule").Module;

package/dist/types/core/gridOptionsService.d.ts

@@ -1,13 +1,12 @@
 import type { NamedBean } from './context/bean';
 import { BeanStub } from './context/beanStub';
 import type { BeanCollection } from './context/context';
-import type { DomLayoutType, GetRowIdFunc, GridOptions } from './entities/gridOptions';
+import type { GridOptions } from './entities/gridOptions';
+import type { Environment } from './environment';
 import type { AgEventType } from './eventTypes';
 import type { AgEvent } from './events';
-import type { GetGroupAggFilteringParams, GetGroupIncludeFooterParams } from './interfaces/iCallbackParams';
 import type { AgGridCommon, WithoutGridCommon } from './interfaces/iCommon';
-import type { RowModelType } from './interfaces/iRowModel';
-import type { IRowNode } from './interfaces/iRowNode';
+import type { ModuleNames } from './modules/moduleNames';
 import type { AnyGridOptions } from './propertyKeys';
 import { GRID_OPTION_DEFAULTS } from './validation/rules/gridOptionsValidations';
 type GetKeys<T, U> = {
@@ -22,8 +21,8 @@ type BooleanProps = Exclude<KeysOfType<boolean>, AnyGridOptions>;
 type NoArgFuncs = KeysOfType<() => any>;
 type AnyArgFuncs = KeysOfType<(arg: 'NO_MATCH') => any>;
 type CallbackProps = Exclude<KeysOfType<(params: AgGridCommon<any, any>) => any>, NoArgFuncs | AnyArgFuncs>;
-type ExtractParamsFromCallback<TCallback> = TCallback extends (params: infer PA) => any ? PA : never;
-type ExtractReturnTypeFromCallback<TCallback> = TCallback extends (params: AgGridCommon<any, any>) => infer RT ? RT : never;
+export type ExtractParamsFromCallback<TCallback> = TCallback extends (params: infer PA) => any ? PA : never;
+export type ExtractReturnTypeFromCallback<TCallback> = TCallback extends (params: AgGridCommon<any, any>) => infer RT ? RT : never;
 type WrappedCallback<K extends CallbackProps, OriginalCallback extends GridOptions[K]> = undefined | ((params: WithoutGridCommon<ExtractParamsFromCallback<OriginalCallback>>) => ExtractReturnTypeFromCallback<OriginalCallback>);
 export interface PropertyChangeSet {
     /** Unique id which can be used to link changes of multiple properties that were updated together.
@@ -56,12 +55,12 @@ export declare function getCoercedGridOptions(gridOptions: GridOptions): GridOpt
 export declare class GridOptionsService extends BeanStub implements NamedBean {
     beanName: "gos";
     private gridOptions;
-    private eGridDiv;
+    eGridDiv: HTMLElement;
     private validationService?;
-    private environment;
+    environment: Environment;
     private api;
+    private gridId;
     wireBeans(beans: BeanCollection): void;
-    private scrollbarWidth;
     private domDataKey;
     private get gridOptionsContext();
     private propertyEventService;
@@ -96,37 +95,10 @@ export declare class GridOptionsService extends BeanStub implements NamedBean {
     addPropertyEventListener<K extends keyof GridOptions>(key: K, listener: PropertyValueChangedListener<K>): void;
     removePropertyEventListener<K extends keyof GridOptions>(key: K, listener: PropertyValueChangedListener<K>): void;
     globalEventHandlerFactory: (restrictToSyncOnly?: boolean) => (eventName: AgEventType, event?: any) => void;
-    getScrollbarWidth(): number;
-    isRowModelType(rowModelType: RowModelType): boolean;
-    isDomLayout(domLayout: DomLayoutType): boolean;
-    isRowSelection(): boolean;
-    useAsyncEvents(): boolean;
-    isGetRowHeightFunction(): boolean;
-    getRowHeightForNode(rowNode: IRowNode, allowEstimate?: boolean, defaultRowHeight?: number): {
-        height: number;
-        estimated: boolean;
-    };
-    private getMasterDetailRowHeight;
-    getRowHeightAsNumber(): number;
-    private isNumeric;
     getDomDataKey(): string;
-    getDomData(element: Node | null, key: string): any;
-    setDomData(element: Element, key: string, value: any): any;
-    getDocument(): Document;
-    getWindow(): Window & typeof globalThis;
-    getRootNode(): Document | ShadowRoot;
-    getActiveDomElement(): Element | null;
-    getAsyncTransactionWaitMillis(): number | undefined;
-    isAnimateRows(): NonNullable<boolean | undefined>;
-    isGroupRowsSticky(): boolean;
-    isColumnsSortingCoupledToGroup(): boolean;
-    getGroupAggFiltering(): ((params: WithoutGridCommon<GetGroupAggFilteringParams>) => boolean) | undefined;
-    getGrandTotalRow(): 'top' | 'bottom' | undefined;
-    getGroupTotalRowCallback(): (params: WithoutGridCommon<GetGroupIncludeFooterParams>) => 'top' | 'bottom' | undefined;
-    isGroupMultiAutoColumn(): NonNullable<boolean | undefined>;
-    isGroupUseEntireRow(pivotMode: boolean): boolean;
     getGridCommonParams<TData = any, TContext = any>(): AgGridCommon<TData, TContext>;
     addGridCommonParams<T extends AgGridCommon<TData, TContext>, TData = any, TContext = any>(params: WithoutGridCommon<T>): T;
-    getRowIdCallback<TData = any>(): ((params: WithoutGridCommon<ExtractParamsFromCallback<GetRowIdFunc<TData>>>) => ExtractReturnTypeFromCallback<GetRowIdFunc<TData>>) | undefined;
+    assertModuleRegistered(moduleName: ModuleNames, reason: string): boolean;
+    isModuleRegistered(moduleName: ModuleNames): boolean;
 }
 export {};

package/dist/types/core/gridOptionsUtils.d.ts

@@ -0,0 +1,54 @@
+import type { DomLayoutType, FillHandleOptions, GetRowIdFunc, GroupSelectionMode, IsRowSelectable, MultiRowSelectionOptions, RowSelectionOptions, SelectionOptions, SingleRowSelectionOptions } from './entities/gridOptions';
+import type { ExtractParamsFromCallback, ExtractReturnTypeFromCallback, GridOptionsService } from './gridOptionsService';
+import type { GetGroupAggFilteringParams, GetGroupIncludeFooterParams } from './interfaces/iCallbackParams';
+import type { WithoutGridCommon } from './interfaces/iCommon';
+import type { IRowNode } from './interfaces/iRowNode';
+export declare function _isClientSideRowModel(gos: GridOptionsService): boolean;
+export declare function _isServerSideRowModel(gos: GridOptionsService): boolean;
+export declare function _isDomLayout(gos: GridOptionsService, domLayout: DomLayoutType): boolean;
+export declare function _isRowSelection(gos: GridOptionsService): boolean;
+export declare function _useAsyncEvents(gos: GridOptionsService): boolean;
+export declare function _isGetRowHeightFunction(gos: GridOptionsService): boolean;
+export declare function _shouldMaintainColumnOrder(gos: GridOptionsService, isPivotColumns: boolean): boolean;
+export declare function _getRowHeightForNode(gos: GridOptionsService, rowNode: IRowNode, allowEstimate?: boolean, defaultRowHeight?: number): {
+    height: number;
+    estimated: boolean;
+};
+export declare function _getRowHeightAsNumber(gos: GridOptionsService): number;
+export declare function _getDomData(gos: GridOptionsService, element: Node | null, key: string): any;
+export declare function _setDomData(gos: GridOptionsService, element: Element, key: string, value: any): any;
+export declare function _getDocument(gos: GridOptionsService): Document;
+export declare function _getWindow(gos: GridOptionsService): Window & typeof globalThis;
+export declare function _getRootNode(gos: GridOptionsService): Document | ShadowRoot;
+export declare function _getActiveDomElement(gos: GridOptionsService): Element | null;
+export declare function _isNothingFocused(gos: GridOptionsService): boolean;
+export declare function _isAnimateRows(gos: GridOptionsService): NonNullable<boolean | undefined>;
+export declare function _isGroupRowsSticky(gos: GridOptionsService): boolean;
+export declare function _isColumnsSortingCoupledToGroup(gos: GridOptionsService): boolean;
+export declare function _getGroupAggFiltering(gos: GridOptionsService): ((params: WithoutGridCommon<GetGroupAggFilteringParams>) => boolean) | undefined;
+export declare function _getGrandTotalRow(gos: GridOptionsService): 'top' | 'bottom' | undefined;
+export declare function _getGroupTotalRowCallback(gos: GridOptionsService): (params: WithoutGridCommon<GetGroupIncludeFooterParams>) => 'top' | 'bottom' | undefined;
+export declare function _isGroupMultiAutoColumn(gos: GridOptionsService): NonNullable<boolean | undefined>;
+export declare function _isGroupUseEntireRow(gos: GridOptionsService, pivotMode: boolean): boolean;
+export declare function _getRowIdCallback<TData = any>(gos: GridOptionsService): ((params: WithoutGridCommon<ExtractParamsFromCallback<GetRowIdFunc<TData>>>) => ExtractReturnTypeFromCallback<GetRowIdFunc<TData>>) | undefined;
+/** Get the selection checkbox configuration. Defaults to enabled. */
+export declare function _getCheckboxes(selection: SelectionOptions): NonNullable<SingleRowSelectionOptions['checkboxes']> | NonNullable<MultiRowSelectionOptions['checkboxes']>;
+/** Get the header checkbox configuration. Defaults to enabled in `multiRow`, otherwise disabled. */
+export declare function _getHeaderCheckbox(selection: SelectionOptions): boolean;
+/** Get the display configuration for disabled checkboxes. Defaults to displaying disabled checkboxes. */
+export declare function _getHideDisabledCheckboxes(selection: SelectionOptions): boolean;
+export declare function _isUsingNewSelectionAPI(gos: GridOptionsService): boolean;
+export declare function _getSuppressMultiRanges(gos: GridOptionsService): boolean;
+export declare function _isCellSelectionEnabled(gos: GridOptionsService): boolean;
+export declare function _isRangeHandleEnabled(gos: GridOptionsService): boolean;
+export declare function _isFillHandleEnabled(gos: GridOptionsService): boolean;
+export declare function _getFillHandle(gos: GridOptionsService): FillHandleOptions | undefined;
+export declare function _getEnableSelection(gos: GridOptionsService): boolean;
+export declare function _getEnableDeselection(gos: GridOptionsService): boolean;
+export declare function _getIsRowSelectable(gos: GridOptionsService): IsRowSelectable | undefined;
+export declare function _getRowSelectionMode(gos: GridOptionsService): RowSelectionOptions['mode'] | undefined;
+export declare function _isMultiRowSelection(gos: GridOptionsService): boolean;
+export declare function _getEnableMultiSelectWithClick(gos: GridOptionsService): boolean;
+export declare function _getGroupSelection(gos: GridOptionsService): GroupSelectionMode | undefined;
+export declare function _getGroupSelectsDescendants(gos: GridOptionsService): boolean;
+export declare function _isSetFilterByDefault(gos: GridOptionsService): boolean;

package/dist/types/core/headerRendering/cells/abstractCell/abstractHeaderCellCtrl.d.ts

@@ -21,6 +21,7 @@ export interface IHeaderResizeFeature {
 export type HeaderCellCtrlInstanceId = BrandedType<string, 'HeaderCellCtrlInstanceId'>;
 export declare abstract class AbstractHeaderCellCtrl<TComp extends IAbstractHeaderCellComp = any, TColumn extends AgColumn | AgColumnGroup = any, TFeature extends IHeaderResizeFeature = any> extends BeanStub {
     static DOM_DATA_KEY_HEADER_CTRL: string;
+    readonly instanceId: HeaderCellCtrlInstanceId;
     private pinnedWidthService;
     protected focusService: FocusService;
     protected userComponentFactory: UserComponentFactory;
@@ -29,7 +30,6 @@ export declare abstract class AbstractHeaderCellCtrl<TComp extends IAbstractHead
     protected menuService: MenuService;
     wireBeans(beans: BeanCollection): void;
     protected beans: BeanCollection;
-    private instanceId;
     private columnGroupChild;
     private parentRowCtrl;
     private isResizing;
@@ -47,12 +47,15 @@ export declare abstract class AbstractHeaderCellCtrl<TComp extends IAbstractHead
     postConstruct(): void;
     protected shouldStopEventPropagation(e: KeyboardEvent): boolean;
     protected getWrapperHasFocus(): boolean;
-    protected setGui(eGui: HTMLElement): void;
+    protected setGui(eGui: HTMLElement, compBean: BeanStub): void;
     private onGuiFocus;
+    protected setupAutoHeight(params: {
+        wrapperElement: HTMLElement;
+        checkMeasuringCallback?: (callback: () => void) => void;
+        compBean: BeanStub;
+    }): void;
     protected onDisplayedColumnsChanged(): void;
-    private refreshFirstAndLastStyles;
-    private refreshAriaColIndex;
-    protected addResizeAndMoveKeyboardListeners(): void;
+    protected addResizeAndMoveKeyboardListeners(compBean: BeanStub): void;
     private refreshTabIndex;
     private onGuiKeyDown;
     private getViewportAdjustedResizeDiff;
@@ -65,10 +68,10 @@ export declare abstract class AbstractHeaderCellCtrl<TComp extends IAbstractHead
     getRowIndex(): number;
     getParentRowCtrl(): HeaderRowCtrl;
     getPinned(): ColumnPinnedType;
-    getInstanceId(): HeaderCellCtrlInstanceId;
     getColumnGroupChild(): AgColumn | AgColumnGroup;
     protected removeDragSource(): void;
     protected handleContextMenuMouseEvent(mouseEvent: MouseEvent | undefined, touchEvent: TouchEvent | undefined, column: AgColumn | AgProvidedColumnGroup): void;
     protected dispatchColumnMouseEvent(eventType: 'columnHeaderContextMenu' | 'columnHeaderClicked', column: AgColumn | AgProvidedColumnGroup): void;
+    protected clearComponent(): void;
     destroy(): void;
 }

package/dist/types/core/headerRendering/cells/column/headerCellCtrl.d.ts

@@ -1,8 +1,10 @@
 import type { UserCompDetails } from '../../../components/framework/userComponentFactory';
 import { HorizontalDirection } from '../../../constants/direction';
+import type { BeanStub } from '../../../context/beanStub';
 import type { BeanCollection } from '../../../context/context';
 import type { AgColumn } from '../../../entities/agColumn';
 import type { ColumnSortState } from '../../../utils/aria';
+import type { HeaderPosition } from '../../common/headerPosition';
 import type { HeaderRowCtrl } from '../../row/headerRowCtrl';
 import type { IAbstractHeaderCellComp } from '../abstractCell/abstractHeaderCellCtrl';
 import { AbstractHeaderCellCtrl } from '../abstractCell/abstractHeaderCellCtrl';
@@ -15,6 +17,7 @@ export interface IHeaderCellComp extends IAbstractHeaderCellComp {
     getUserCompInstance(): IHeader | undefined;
 }
 type HeaderAriaDescriptionKey = 'filter' | 'menu' | 'sort' | 'selectAll' | 'filterButton';
+type RefreshFunction = 'updateSortable' | 'tooltip' | 'headerClasses' | 'wrapText' | 'measuring' | 'resize';
 export declare class HeaderCellCtrl extends AbstractHeaderCellCtrl<IHeaderCellComp, AgColumn, ResizeFeature> {
     private refreshFunctions;
     private selectAllFeature;
@@ -29,9 +32,10 @@ export declare class HeaderCellCtrl extends AbstractHeaderCellCtrl<IHeaderCellCo
     private ariaDescriptionProperties;
     private tooltipFeature;
     constructor(column: AgColumn, beans: BeanCollection, parentRowCtrl: HeaderRowCtrl);
-    setComp(comp: IHeaderCellComp, eGui: HTMLElement, eResize: HTMLElement, eHeaderCompWrapper: HTMLElement): void;
+    setComp(comp: IHeaderCellComp, eGui: HTMLElement, eResize: HTMLElement, eHeaderCompWrapper: HTMLElement, compBean: BeanStub | undefined): void;
     protected resizeHeader(delta: number, shiftKey: boolean): void;
     protected moveHeader(hDirection: HorizontalDirection): void;
+    protected restoreFocus(previousPosition: HeaderPosition): void;
     private setupUserComp;
     private setCompDetails;
     private lookupUserCompDetails;
@@ -48,26 +52,23 @@ export declare class HeaderCellCtrl extends AbstractHeaderCellCtrl<IHeaderCellCo
     setDragSource(eSource: HTMLElement | undefined): void;
     private createDragItem;
     private updateState;
-    addRefreshFunction(func: () => void): void;
+    setRefreshFunction(name: RefreshFunction, func: () => void): void;
     private refresh;
     private refreshHeaderComp;
     attemptHeaderCompRefresh(params: IHeaderParams): boolean;
     private calculateDisplayName;
     private checkDisplayName;
     private workOutDraggable;
-    private onColumnRowGroupChanged;
-    private onColumnPivotChanged;
-    private onColumnValueChanged;
     private setupWidth;
     private setupMovingCss;
     private setupMenuClass;
     private setupSortableClass;
     private setupFilterClass;
     private setupWrapTextClass;
+    private onHeaderHighlightChanged;
     protected onDisplayedColumnsChanged(): void;
     private onHeaderHeightChanged;
     private refreshSpanHeaderHeight;
-    private setupAutoHeight;
     private refreshAriaSort;
     private refreshAriaMenu;
     private refreshAriaFilterButton;

package/dist/types/core/headerRendering/cells/column/selectAllFeature.d.ts

@@ -8,10 +8,12 @@ export declare class SelectAllFeature extends BeanStub {
     wireBeans(beans: BeanCollection): void;
     private cbSelectAllVisible;
     private processingEventFromCheckbox;
+    private selectionOptions;
     private column;
     private headerCellCtrl;
     private cbSelectAll;
     constructor(column: AgColumn);
+    postConstruct(): void;
     onSpaceKeyDown(e: KeyboardEvent): void;
     getCheckboxGui(): HTMLElement;
     setComp(ctrl: HeaderCellCtrl): void;
@@ -25,6 +27,10 @@ export declare class SelectAllFeature extends BeanStub {
     private checkSelectionType;
     private checkRightRowModelType;
     private onCbSelectAll;
+    /**
+     * Checkbox is enabled when either the `headerCheckbox` option is enabled in the new selection API
+     * or `headerCheckboxSelection` is enabled in the legacy API.
+     */
     private isCheckboxSelection;
     private isFilteredOnly;
     private isCurrentPageOnly;

package/dist/types/core/headerRendering/cells/columnGroup/headerGroupCellComp.d.ts

@@ -2,6 +2,7 @@ import { AbstractHeaderCellComp } from '../abstractCell/abstractHeaderCellComp';
 import type { HeaderGroupCellCtrl } from './headerGroupCellCtrl';
 export declare class HeaderGroupCellComp extends AbstractHeaderCellComp<HeaderGroupCellCtrl> {
     private eResize;
+    private readonly eHeaderCompWrapper;
     private headerGroupComp;
     constructor(ctrl: HeaderGroupCellCtrl);
     postConstruct(): void;