ag-grid-community 32.3.2 → 33.0.0

package/dist/types/src/gridOptionsInitial.d.ts

@@ -0,0 +1,88 @@
+import type { GridOptions } from './entities/gridOptions';
+export declare const INITIAL_GRID_OPTION_KEYS: {
+    enableBrowserTooltips: boolean;
+    tooltipTrigger: boolean;
+    tooltipMouseTrack: boolean;
+    tooltipShowMode: boolean;
+    tooltipInteraction: boolean;
+    defaultColGroupDef: boolean;
+    suppressAutoSize: boolean;
+    skipHeaderOnAutoSize: boolean;
+    autoSizeStrategy: boolean;
+    components: boolean;
+    stopEditingWhenCellsLoseFocus: boolean;
+    undoRedoCellEditing: boolean;
+    undoRedoCellEditingLimit: boolean;
+    excelStyles: boolean;
+    cacheQuickFilter: boolean;
+    customChartThemes: boolean;
+    chartThemeOverrides: boolean;
+    chartToolPanelsDef: boolean;
+    loadingCellRendererSelector: boolean;
+    localeText: boolean;
+    keepDetailRows: boolean;
+    keepDetailRowsCount: boolean;
+    detailRowHeight: boolean;
+    detailRowAutoHeight: boolean;
+    tabIndex: boolean;
+    valueCache: boolean;
+    valueCacheNeverExpires: boolean;
+    enableCellExpressions: boolean;
+    suppressTouch: boolean;
+    suppressBrowserResizeObserver: boolean;
+    suppressPropertyNamesCheck: boolean;
+    debug: boolean;
+    dragAndDropImageComponent: boolean;
+    loadingOverlayComponent: boolean;
+    suppressLoadingOverlay: boolean;
+    noRowsOverlayComponent: boolean;
+    paginationPageSizeSelector: boolean;
+    paginateChildRows: boolean;
+    pivotPanelShow: boolean;
+    pivotSuppressAutoColumn: boolean;
+    suppressExpandablePivotGroups: boolean;
+    aggFuncs: boolean;
+    allowShowChangeAfterFilter: boolean;
+    ensureDomOrder: boolean;
+    enableRtl: boolean;
+    suppressColumnVirtualisation: boolean;
+    suppressMaxRenderedRowRestriction: boolean;
+    suppressRowVirtualisation: boolean;
+    rowDragText: boolean;
+    groupLockGroupColumns: boolean;
+    suppressGroupRowsSticky: boolean;
+    rowModelType: boolean;
+    cacheOverflowSize: boolean;
+    infiniteInitialRowCount: boolean;
+    serverSideInitialRowCount: boolean;
+    maxBlocksInCache: boolean;
+    maxConcurrentDatasourceRequests: boolean;
+    blockLoadDebounceMillis: boolean;
+    serverSideOnlyRefreshFilteredGroups: boolean;
+    serverSidePivotResultFieldSeparator: boolean;
+    viewportRowModelPageSize: boolean;
+    viewportRowModelBufferSize: boolean;
+    debounceVerticalScrollbar: boolean;
+    suppressAnimationFrame: boolean;
+    suppressPreventDefaultOnMouseWheel: boolean;
+    scrollbarWidth: boolean;
+    icons: boolean;
+    suppressRowTransform: boolean;
+    gridId: boolean;
+    enableGroupEdit: boolean;
+    initialState: boolean;
+    processUnpinnedColumns: boolean;
+    createChartContainer: boolean;
+    getLocaleText: boolean;
+    getRowId: boolean;
+    reactiveCustomComponents: boolean;
+    columnMenu: boolean;
+    suppressSetFilterByDefault: boolean;
+    getDataPath: boolean;
+};
+type InitialGridOptionKey = keyof typeof INITIAL_GRID_OPTION_KEYS;
+export type ManagedGridOptionKey = Exclude<keyof GridOptions, InitialGridOptionKey>;
+export type ManagedGridOptions<TData = any> = {
+    [K in ManagedGridOptionKey]?: GridOptions<TData>[K];
+};
+export {};

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

@@ -0,0 +1,108 @@
+import type { NamedBean } from './context/bean';
+import { BeanStub } from './context/beanStub';
+import type { BeanCollection } from './context/context';
+import type { GridOptions } from './entities/gridOptions';
+import type { AgEventType } from './eventTypes';
+import type { AgEvent } from './events';
+import type { GridOptionOrDefault } from './gridOptionsDefault';
+import type { AgGridCommon, WithoutGridCommon } from './interfaces/iCommon';
+import type { ModuleName, ValidationModuleName } from './interfaces/iModule';
+import type { RowModelType } from './interfaces/iRowModel';
+import type { AnyGridOptions } from './propertyKeys';
+import type { MissingModuleErrors } from './validation/errorMessages/errorText';
+type GetKeys<T, U> = {
+    [K in keyof T]: T[K] extends U | undefined ? K : never;
+}[keyof T];
+/**
+ * Get all the GridOption properties that strictly contain the provided type.
+ * Does not include `any` properties.
+ */
+export type KeysOfType<U> = Exclude<GetKeys<GridOptions, U>, AnyGridOptions>;
+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>;
+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.
+     * i.e a user updated multiple properties at the same time.
+     */
+    id: number;
+    /** All the properties that have been updated in this change set */
+    properties: (keyof GridOptions)[];
+}
+export type PropertyChangedSource = 'api' | 'gridOptionsUpdated';
+export interface PropertyChangedEvent extends AgEvent {
+    type: 'gridPropertyChanged';
+    changeSet: PropertyChangeSet | undefined;
+    source: PropertyChangedSource;
+}
+/**
+ * For boolean properties the changed value will have been coerced to a boolean, so we do not want the type to include the undefined value.
+ */
+type GridOptionsOrBooleanCoercedValue<K extends keyof GridOptions> = K extends BooleanProps ? boolean : GridOptions[K];
+export interface PropertyValueChangedEvent<K extends keyof GridOptions> extends AgEvent {
+    type: K;
+    changeSet: PropertyChangeSet | undefined;
+    currentValue: GridOptionsOrBooleanCoercedValue<K>;
+    previousValue: GridOptionsOrBooleanCoercedValue<K>;
+    source: PropertyChangedSource;
+}
+export type PropertyChangedListener = (event: PropertyChangedEvent) => void;
+export type PropertyValueChangedListener<K extends keyof GridOptions> = (event: PropertyValueChangedEvent<K>) => void;
+export declare class GridOptionsService extends BeanStub implements NamedBean {
+    beanName: "gos";
+    private gridOptions;
+    private validation?;
+    private api;
+    private gridId;
+    wireBeans(beans: BeanCollection): void;
+    private domDataKey;
+    /** This is only used for the main DOM element */
+    readonly gridInstanceId: number;
+    private get gridOptionsContext();
+    private propEventSvc;
+    postConstruct(): void;
+    /**
+     * Get the raw value of the GridOptions property provided.
+     * @param property
+     */
+    get<K extends keyof GridOptions>(property: K): GridOptionOrDefault<K>;
+    /**
+     * Get the GridOption callback but wrapped so that the common params of api and context are automatically applied to the params.
+     * @param property GridOption callback properties based on the fact that this property has a callback with params extending AgGridCommon
+     */
+    getCallback<K extends CallbackProps>(property: K): WrappedCallback<K, GridOptions[K]>;
+    /**
+     * Returns `true` if a value has been specified for this GridOption.
+     * @param property GridOption property
+     */
+    exists(property: keyof GridOptions): boolean;
+    /**
+     * Wrap the user callback and attach the api and context to the params object on the way through.
+     * @param callback User provided callback
+     * @returns Wrapped callback where the params object not require api and context
+     */
+    private mergeGridCommonParams;
+    updateGridOptions({ options, force, source, }: {
+        options: Partial<GridOptions>;
+        force?: boolean;
+        source?: PropertyChangedSource;
+    }): void;
+    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;
+    getDomDataKey(): string;
+    getGridCommonParams<TData = any, TContext = any>(): AgGridCommon<TData, TContext>;
+    addGridCommonParams<T extends AgGridCommon<TData, TContext>, TData = any, TContext = any>(params: WithoutGridCommon<T>): T;
+    assertModuleRegistered<TId extends keyof MissingModuleErrors, TShowMessageAtCallLocation = MissingModuleErrors[TId]>(moduleName: ValidationModuleName | ValidationModuleName[], reasonOrId: string | TId): boolean;
+    getModuleErrorParams(): {
+        gridScoped: boolean;
+        gridId: string;
+        rowModelType: RowModelType;
+    };
+    isModuleRegistered(moduleName: ModuleName): boolean;
+}
+export {};

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

@@ -0,0 +1,74 @@
+import type { GridApi } from './api/gridApi';
+import type { BeanCollection } from './context/context';
+import type { CheckboxLocation, DomLayoutType, FillHandleOptions, GetRowIdFunc, GridOptions, GroupSelectionMode, IsRowSelectable, MultiRowSelectionOptions, RowSelectionMode, RowSelectionOptions, SelectAllMode, SingleRowSelectionOptions } from './entities/gridOptions';
+import type { RowNode } from './entities/rowNode';
+import type { ExtractParamsFromCallback, ExtractReturnTypeFromCallback, GridOptionsService } from './gridOptionsService';
+import type { GetGroupAggFilteringParams, GetGroupIncludeFooterParams } from './interfaces/iCallbackParams';
+import type { IClientSideRowModel } from './interfaces/iClientSideRowModel';
+import type { WithoutGridCommon } from './interfaces/iCommon';
+import type { IRowModel } from './interfaces/iRowModel';
+import type { IRowNode } from './interfaces/iRowNode';
+import type { IServerSideRowModel } from './interfaces/iServerSideRowModel';
+export declare function _isClientSideRowModel(gos: GridOptionsService, rowModel?: IRowModel): rowModel is IClientSideRowModel;
+export declare function _isServerSideRowModel(gos: GridOptionsService, rowModel?: IRowModel): rowModel is IServerSideRowModel;
+export declare function _isDomLayout(gos: GridOptionsService, domLayout: DomLayoutType): boolean;
+export declare function _isRowSelection(gos: GridOptionsService): boolean;
+export declare function _isGetRowHeightFunction(gos: GridOptionsService): boolean;
+export declare function _shouldMaintainColumnOrder(gos: GridOptionsService, isPivotColumns: boolean): boolean;
+export declare function _getRowHeightForNode(beans: BeanCollection, rowNode: IRowNode, allowEstimate?: boolean, defaultRowHeight?: number): {
+    height: number;
+    estimated: boolean;
+};
+export declare function _getRowHeightAsNumber(beans: BeanCollection): 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(beans: BeanCollection): Document;
+export declare function _getWindow(beans: BeanCollection): Window & typeof globalThis;
+export declare function _getRootNode(beans: BeanCollection): Document | ShadowRoot;
+export declare function _getActiveDomElement(beans: BeanCollection): Element | null;
+export declare function _getPageBody(beans: BeanCollection): HTMLElement | ShadowRoot;
+export declare function _anchorElementToMouseMoveEvent(element: HTMLElement, mouseMoveEvent: MouseEvent | Touch, beans: BeanCollection): void;
+export declare function _isNothingFocused(beans: BeanCollection): 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;
+export declare function _canSkipShowingRowGroup(gos: GridOptionsService, node: RowNode): boolean;
+export declare function _getMaxConcurrentDatasourceRequests(gos: GridOptionsService): number | undefined;
+/** Get the selection checkbox configuration. Defaults to enabled. */
+export declare function _shouldUpdateColVisibilityAfterGroup(gos: GridOptionsService, isGrouped: boolean): boolean;
+/** Get the selection checkbox configuration. Defaults to enabled. */
+export declare function _getCheckboxes(selection: RowSelectionOptions): NonNullable<SingleRowSelectionOptions['checkboxes']> | NonNullable<MultiRowSelectionOptions['checkboxes']>;
+/** Get the header checkbox configuration. Defaults to enabled in `multiRow`, otherwise disabled. */
+export declare function _getHeaderCheckbox(selection: RowSelectionOptions): boolean;
+export declare function _getCheckboxLocation(rowSelection: GridOptions['rowSelection']): CheckboxLocation | undefined;
+/** Get the display configuration for disabled checkboxes. Defaults to displaying disabled checkboxes. */
+export declare function _getHideDisabledCheckboxes(selection: RowSelectionOptions): boolean;
+export declare function _isUsingNewRowSelectionAPI(gos: GridOptionsService): boolean;
+export declare function _isUsingNewCellSelectionAPI(gos: GridOptionsService): boolean;
+export declare function _getSuppressMultiRanges(gos: GridOptionsService): boolean;
+export declare function _isCellSelectionEnabled(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): RowSelectionMode | undefined;
+export declare function _isMultiRowSelection(gos: GridOptionsService): boolean;
+export declare function _getEnableSelectionWithoutKeys(gos: GridOptionsService): boolean;
+export declare function _getGroupSelection(gos: GridOptionsService): GroupSelectionMode | undefined;
+export declare function _getSelectAll(gos: GridOptionsService, defaultValue: boolean): SelectAllMode | undefined;
+export declare function _getSelectAll(gos: GridOptionsService): SelectAllMode;
+export declare function _getGroupSelectsDescendants(gos: GridOptionsService): boolean;
+export declare function _isSetFilterByDefault(gos: GridOptionsService): boolean;
+export declare function _isLegacyMenuEnabled(gos: GridOptionsService): boolean;
+export declare function _isColumnMenuAnchoringEnabled(gos: GridOptionsService): boolean;
+export declare function _areAdditionalColumnMenuItemsEnabled(gos: GridOptionsService): boolean;
+export declare function _getCallbackForEvent(eventName: string): string;
+/** Combines component props / attributes with the provided gridOptions returning a new combined gridOptions object */
+export declare function _combineAttributesAndGridOptions(gridOptions: GridOptions | undefined, component: any, gridOptionsKeys: string[]): GridOptions;
+export declare function _processOnChange(changes: any, api: GridApi): void;

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

@@ -0,0 +1,59 @@
+import type { HorizontalDirection } from '../../../constants/direction';
+import { BeanStub } from '../../../context/beanStub';
+import type { DragSource } from '../../../dragAndDrop/dragAndDropService';
+import type { AgColumn } from '../../../entities/agColumn';
+import type { AgColumnGroup } from '../../../entities/agColumnGroup';
+import type { AgProvidedColumnGroup } from '../../../entities/agProvidedColumnGroup';
+import type { BrandedType } from '../../../interfaces/brandedType';
+import type { HeaderRowCtrl } from '../../row/headerRowCtrl';
+export interface IAbstractHeaderCellComp {
+    addOrRemoveCssClass(cssClassName: string, on: boolean): void;
+}
+export interface IHeaderResizeFeature {
+    toggleColumnResizing(resizing: boolean): void;
+}
+export type HeaderCellCtrlInstanceId = BrandedType<string, 'HeaderCellCtrlInstanceId'>;
+export declare const DOM_DATA_KEY_HEADER_CTRL = "headerCtrl";
+export declare abstract class AbstractHeaderCellCtrl<TComp extends IAbstractHeaderCellComp = any, TColumn extends AgColumn | AgColumnGroup = any, TFeature extends IHeaderResizeFeature = any> extends BeanStub {
+    readonly column: TColumn;
+    readonly rowCtrl: HeaderRowCtrl;
+    readonly instanceId: HeaderCellCtrlInstanceId;
+    private isResizing;
+    private resizeToggleTimeout;
+    protected resizeMultiplier: number;
+    eGui: HTMLElement;
+    protected resizeFeature: TFeature | null;
+    protected comp: TComp;
+    lastFocusEvent: KeyboardEvent | null;
+    protected dragSource: DragSource | null;
+    protected abstract resizeHeader(delta: number, shiftKey: boolean): void;
+    constructor(column: TColumn, rowCtrl: HeaderRowCtrl);
+    postConstruct(): void;
+    protected shouldStopEventPropagation(event: KeyboardEvent): boolean;
+    protected getWrapperHasFocus(): boolean;
+    protected setGui(eGui: HTMLElement, compBean: BeanStub): void;
+    private onGuiFocus;
+    protected setupAutoHeight(params: {
+        wrapperElement: HTMLElement;
+        checkMeasuringCallback?: (callback: () => void) => void;
+        compBean: BeanStub;
+    }): void;
+    protected onDisplayedColumnsChanged(): void;
+    protected addResizeAndMoveKeyboardListeners(compBean: BeanStub): void;
+    private refreshTabIndex;
+    private onGuiKeyDown;
+    protected moveHeader(hDirection: HorizontalDirection): void;
+    private getViewportAdjustedResizeDiff;
+    private getResizeDiff;
+    private onGuiKeyUp;
+    protected handleKeyDown(e: KeyboardEvent): void;
+    private addDomData;
+    focus(event?: KeyboardEvent): boolean;
+    protected focusThis(): void;
+    protected removeDragSource(): void;
+    protected handleContextMenuMouseEvent(mouseEvent: MouseEvent | undefined, touchEvent: TouchEvent | undefined, column: AgColumn | AgProvidedColumnGroup): void;
+    protected dispatchColumnMouseEvent(eventType: 'columnHeaderContextMenu' | 'columnHeaderClicked', column: AgColumn | AgProvidedColumnGroup): void;
+    private setColHeaderHeight;
+    protected clearComponent(): void;
+    destroy(): void;
+}

package/dist/types/src/headerRendering/cells/column/headerCellComp.d.ts

@@ -0,0 +1,15 @@
+import { AbstractHeaderCellComp } from '../abstractCell/abstractHeaderCellComp';
+import type { HeaderCellCtrl } from './headerCellCtrl';
+export declare class HeaderCellComp extends AbstractHeaderCellComp<HeaderCellCtrl> {
+    private readonly eResize;
+    private readonly eHeaderCompWrapper;
+    private headerComp;
+    private headerCompGui;
+    private headerCompVersion;
+    constructor(ctrl: HeaderCellCtrl);
+    postConstruct(): void;
+    destroy(): void;
+    private destroyHeaderComp;
+    private setUserCompDetails;
+    private afterCompCreated;
+}

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

@@ -0,0 +1,78 @@
+import type { ResizeFeature } from '../../../columnResize/resizeFeature';
+import type { BeanStub } from '../../../context/beanStub';
+import type { AgColumn } from '../../../entities/agColumn';
+import type { UserCompDetails } from '../../../interfaces/iUserCompDetails';
+import type { ColumnSortState } from '../../../utils/aria';
+import type { IAbstractHeaderCellComp } from '../abstractCell/abstractHeaderCellCtrl';
+import { AbstractHeaderCellCtrl } from '../abstractCell/abstractHeaderCellCtrl';
+import type { IHeader } from './headerComp';
+export interface IHeaderCellComp extends IAbstractHeaderCellComp {
+    setWidth(width: string): void;
+    setAriaSort(sort?: ColumnSortState): void;
+    setUserCompDetails(compDetails: UserCompDetails): void;
+    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?;
+    private sortable;
+    private displayName;
+    private draggable;
+    private menuEnabled;
+    private openFilterEnabled;
+    private dragSourceElement;
+    private userCompDetails;
+    private userHeaderClasses;
+    private ariaDescriptionProperties;
+    private tooltipFeature;
+    setComp(comp: IHeaderCellComp, eGui: HTMLElement, eResize: HTMLElement, eHeaderCompWrapper: HTMLElement, compBeanInput: BeanStub | undefined): void;
+    protected resizeHeader(delta: number, shiftKey: boolean): void;
+    private setupUserComp;
+    private setCompDetails;
+    private lookupUserCompDetails;
+    private createParams;
+    private setupSelectAll;
+    getSelectAllGui(): HTMLElement | undefined;
+    protected handleKeyDown(e: KeyboardEvent): void;
+    private onEnterKeyDown;
+    private showMenuOnKeyPress;
+    private onFocusIn;
+    private onFocusOut;
+    private setupTooltip;
+    private setupClassesFromColDef;
+    setDragSource(eSource: HTMLElement | undefined): void;
+    private updateState;
+    setRefreshFunction(name: RefreshFunction, func: () => void): void;
+    private refresh;
+    private refreshHeaderComp;
+    private attemptHeaderCompRefresh;
+    private calculateDisplayName;
+    private checkDisplayName;
+    private workOutDraggable;
+    private setupWidth;
+    private setupMovingCss;
+    private setupMenuClass;
+    private setupSortableClass;
+    private setupFilterClass;
+    private setupWrapTextClass;
+    private onHeaderHighlightChanged;
+    protected onDisplayedColumnsChanged(): void;
+    private onHeaderHeightChanged;
+    private refreshSpanHeaderHeight;
+    private refreshAriaSort;
+    private refreshAriaMenu;
+    private refreshAriaFilterButton;
+    private refreshAriaFiltered;
+    setAriaDescriptionProperty(property: HeaderAriaDescriptionKey, value: string | null): void;
+    announceAriaDescription(): void;
+    private refreshAria;
+    private addColumnHoverListener;
+    private addActiveHeaderMouseListeners;
+    private handleMouseOverChange;
+    private setActiveHeader;
+    getAnchorElementForMenu(isFilter?: boolean): HTMLElement;
+    destroy(): void;
+}
+export {};

package/dist/types/src/headerRendering/cells/column/headerComp.d.ts

@@ -0,0 +1,131 @@
+import type { SortDirection } from '../../../entities/colDef';
+import type { Column } from '../../../interfaces/iColumn';
+import type { AgGridCommon } from '../../../interfaces/iCommon';
+import type { IComponent } from '../../../interfaces/iComponent';
+import { Component } from '../../../widgets/component';
+export interface IHeaderParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    /** The column the header is for. */
+    column: Column;
+    /**
+     * The name to display for the column.
+     * If the column is using a headerValueGetter, the displayName will take this into account.
+     */
+    displayName: string;
+    /**
+     * Whether sorting is enabled for the column.
+     * Only put sort logic into your header if this is true.
+     */
+    enableSorting: boolean | undefined;
+    /**
+     * Whether menu is enabled for the column.
+     * Only display a menu button in your header if this is true.
+     */
+    enableMenu: boolean;
+    /**
+     * Whether filter button should be displayed in the header (for new column menu).
+     */
+    enableFilterButton: boolean;
+    /**
+     * Whether filter icon should be displayed in the header (for legacy tabbed column menu).
+     */
+    enableFilterIcon: boolean;
+    /**
+     * Callback to request the grid to show the column menu.
+     * Pass in the html element of the column menu button to have the
+     * grid position the menu over the button.
+     */
+    showColumnMenu: (source: HTMLElement) => void;
+    /**
+     * Callback to request the grid to show the column menu.
+     * Similar to `showColumnMenu`, but will position the menu next to the provided `mouseEvent`.
+     */
+    showColumnMenuAfterMouseClick: (mouseEvent: MouseEvent | Touch) => void;
+    /**
+     * Callback to request the grid to show the filter.
+     * Pass in the html element of the filter button to have the
+     * grid position the menu over the button.
+     */
+    showFilter: (source: HTMLElement) => void;
+    /**
+     * Callback to progress the sort for this column.
+     * The grid will decide the next sort direction eg ascending, descending or 'no sort'.
+     * Pass `multiSort=true` if you want to do a multi sort (eg user has Shift held down when they click).
+     */
+    progressSort: (multiSort?: boolean) => void;
+    /**
+     * Callback to set the sort for this column.
+     * Pass the sort direction to use ignoring the current sort eg one of 'asc', 'desc' or null (for no sort).
+     * Pass `multiSort=true` if you want to do a multi sort (eg user has Shift held down when they click)
+     */
+    setSort: (sort: SortDirection, multiSort?: boolean) => void;
+    /** Custom header template if provided to `headerComponentParams`, otherwise will be `undefined`. See [Header Templates](https://ag-grid.com/javascript-data-grid/column-headers/#header-templates) */
+    template?: string;
+    /** The component to use for inside the header (replaces the text value and leaves the remainder of the Grid's original component). */
+    innerHeaderComponent?: any;
+    /** Additional params to customise to the `innerHeaderComponent`. */
+    innerHeaderComponentParams?: any;
+    /**
+     * The header the grid provides.
+     * The custom header component is a child of the grid provided header.
+     * The grid's header component is what contains the grid managed functionality such as resizing, keyboard navigation etc.
+     * This is provided should you want to make changes to this cell,
+     * eg add ARIA tags, or add keyboard event listener (as focus goes here when navigating to the header).
+     */
+    eGridHeader: HTMLElement;
+    /**
+     * Sets a tooltip to the main element of this component.
+     * @param value The value to be displayed by the tooltip
+     * @param shouldDisplayTooltip A function returning a boolean that allows the tooltip to be displayed conditionally. This option does not work when `enableBrowserTooltips={true}`.
+     */
+    setTooltip: (value: string, shouldDisplayTooltip?: () => boolean) => void;
+}
+export interface IHeader {
+    /** Get the header to refresh. Gets called whenever Column Defs are updated. */
+    refresh(params: IHeaderParams): boolean;
+}
+export interface IHeaderComp extends IHeader, IComponent<IHeaderParams> {
+}
+export interface IInnerHeaderComponent<TData = any, TContext = any, TParams extends Readonly<IHeaderParams<TData, TContext>> = IHeaderParams<TData, TContext>> extends IComponent<TParams>, IHeader {
+}
+export declare class HeaderComp extends Component implements IHeaderComp {
+    private eFilter;
+    eFilterButton?: HTMLElement;
+    private eSortIndicator;
+    eMenu?: HTMLElement;
+    private eLabel;
+    private eText;
+    /**
+     * Selectors for custom headers templates
+     */
+    private readonly eSortOrder;
+    private readonly eSortAsc;
+    private readonly eSortDesc;
+    private readonly eSortMixed;
+    private readonly eSortNone;
+    params: IHeaderParams;
+    private currentDisplayName;
+    private currentTemplate;
+    private currentShowMenu;
+    private currentSuppressMenuHide;
+    private currentSort;
+    private innerHeaderComponent;
+    private isLoadingInnerComponent;
+    refresh(params: IHeaderParams): boolean;
+    private workOutTemplate;
+    init(params: IHeaderParams): void;
+    private workOutInnerHeaderComponent;
+    private setDisplayName;
+    private addInIcon;
+    private workOutShowMenu;
+    shouldSuppressMenuHide(): boolean;
+    private setMenu;
+    onMenuKeyboardShortcut(isFilterShortcut: boolean): boolean;
+    private setupSort;
+    private setupFilterIcon;
+    private setupFilterButton;
+    private configureFilter;
+    private onFilterChangedIcon;
+    private onFilterChangedButton;
+    getAnchorElementForMenu(isFilter?: boolean): HTMLElement;
+    destroy(): void;
+}

package/dist/types/src/headerRendering/cells/columnGroup/headerGroupCellCtrl.d.ts

@@ -0,0 +1,42 @@
+import type { GroupResizeFeature } from '../../../columnResize/groupResizeFeature';
+import type { BeanStub } from '../../../context/beanStub';
+import type { AgColumnGroup } from '../../../entities/agColumnGroup';
+import type { ColumnEventType } from '../../../events';
+import type { UserCompDetails } from '../../../interfaces/iUserCompDetails';
+import type { IAbstractHeaderCellComp } from '../abstractCell/abstractHeaderCellCtrl';
+import { AbstractHeaderCellCtrl } from '../abstractCell/abstractHeaderCellCtrl';
+import type { IHeaderGroupComp } from './headerGroupComp';
+export interface IHeaderGroupCellComp extends IAbstractHeaderCellComp {
+    setResizableDisplayed(displayed: boolean): void;
+    setWidth(width: string): void;
+    setHeaderWrapperMaxHeight(value: number | null): void;
+    setHeaderWrapperHidden(value: boolean): void;
+    setAriaExpanded(expanded: 'true' | 'false' | undefined): void;
+    setUserCompDetails(compDetails: UserCompDetails): void;
+    getUserCompInstance(): IHeaderGroupComp | undefined;
+}
+export declare class HeaderGroupCellCtrl extends AbstractHeaderCellCtrl<IHeaderGroupCellComp, AgColumnGroup, GroupResizeFeature> {
+    private expandable;
+    private displayName;
+    private tooltipFeature;
+    setComp(comp: IHeaderGroupCellComp, eGui: HTMLElement, eResize: HTMLElement, eHeaderCompWrapper: HTMLElement, compBean: BeanStub<any> | undefined): void;
+    private refreshMaxHeaderHeight;
+    private addHighlightListeners;
+    private onLeafColumnHighlightChanged;
+    protected resizeHeader(delta: number, shiftKey: boolean): void;
+    resizeLeafColumnsToFit(source: ColumnEventType): void;
+    private setupUserComp;
+    private addHeaderMouseListeners;
+    private handleMouseOverChange;
+    private setupTooltip;
+    private setupExpandable;
+    private refreshExpanded;
+    private addClasses;
+    private setupMovingCss;
+    private onSuppressColMoveChange;
+    private onFocusIn;
+    protected handleKeyDown(e: KeyboardEvent): void;
+    setDragSource(eHeaderGroup: HTMLElement): void;
+    private isSuppressMoving;
+    destroy(): void;
+}

package/dist/types/src/headerRendering/cells/columnGroup/headerGroupComp.d.ts

@@ -0,0 +1,50 @@
+import type { ColumnGroup } from '../../../interfaces/iColumn';
+import type { AgGridCommon } from '../../../interfaces/iCommon';
+import type { IComponent } from '../../../interfaces/iComponent';
+import { Component } from '../../../widgets/component';
+export interface IHeaderGroupParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    /** The column group the header is for. */
+    columnGroup: ColumnGroup;
+    /**
+     * The text label to render.
+     * If the column is using a headerValueGetter, the displayName will take this into account.
+     */
+    displayName: string;
+    /** Opens / closes the column group */
+    setExpanded: (expanded: boolean) => void;
+    /**
+     * Sets a tooltip to the main element of this component.
+     * @param value The value to be displayed by the tooltip
+     * @param shouldDisplayTooltip A function returning a boolean that allows the tooltip to be displayed conditionally. This option does not work when `enableBrowserTooltips={true}`.
+     */
+    setTooltip: (value: string, shouldDisplayTooltip?: () => boolean) => void;
+    /** The component to use for inside the header group (replaces the text value and leaves the remainder of the Grid's original component). */
+    innerHeaderGroupComponent?: any;
+    /** Additional params to customise to the `innerHeaderGroupComponent`. */
+    innerHeaderGroupComponentParams?: any;
+}
+export interface IHeaderGroup {
+}
+export interface IHeaderGroupComp extends IHeaderGroup, IComponent<IHeaderGroupParams> {
+}
+export interface IInnerHeaderGroupComponent<TData = any, TContext = any, TParams extends Readonly<IHeaderGroupParams<TData, TContext>> = IHeaderGroupParams<TData, TContext>> extends IComponent<TParams>, IHeaderGroup {
+}
+export declare class HeaderGroupComp extends Component implements IHeaderGroupComp {
+    private params;
+    private readonly agOpened;
+    private readonly agClosed;
+    private readonly agLabel;
+    private innerHeaderGroupComponent;
+    private isLoadingInnerComponent;
+    constructor();
+    init(params: IHeaderGroupParams): void;
+    private checkWarnings;
+    private workOutInnerHeaderGroupComponent;
+    private setupExpandIcons;
+    private addTouchAndClickListeners;
+    private updateIconVisibility;
+    private addInIcon;
+    private addGroupExpandIcon;
+    private setupLabel;
+    destroy(): void;
+}