ag-grid-community 32.3.2 → 33.0.0

package/dist/types/src/columnResize/columnResizeService.d.ts

@@ -0,0 +1,33 @@
+import type { ColKey } from '../columns/columnModel';
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { AgColumn } from '../entities/agColumn';
+import type { AgColumnGroup } from '../entities/agColumnGroup';
+import type { ColumnEventType } from '../events';
+import type { HeaderCellCtrl, IHeaderCellComp } from '../headerRendering/cells/column/headerCellCtrl';
+import type { IHeaderGroupCellComp } from '../headerRendering/cells/columnGroup/headerGroupCellCtrl';
+import type { ColumnPinnedType } from '../interfaces/iColumn';
+import { GroupResizeFeature } from './groupResizeFeature';
+import { ResizeFeature } from './resizeFeature';
+export interface ColumnResizeSet {
+    columns: AgColumn[];
+    ratios: number[];
+    width: number;
+}
+export declare class ColumnResizeService extends BeanStub implements NamedBean {
+    beanName: "colResize";
+    setColumnWidths(columnWidths: {
+        key: ColKey;
+        newWidth: number;
+    }[], shiftKey: boolean, // @takeFromAdjacent - if user has 'shift' pressed, then pixels are taken from adjacent column
+    finished: boolean, // @finished - ends up in the event, tells the user if more events are to come
+    source: ColumnEventType): void;
+    resizeColumnSets(params: {
+        resizeSets: ColumnResizeSet[];
+        finished: boolean;
+        source: ColumnEventType;
+    }): void;
+    resizeHeader(column: AgColumn, delta: number, shiftKey: boolean): void;
+    createResizeFeature(pinned: ColumnPinnedType, column: AgColumn, eResize: HTMLElement, comp: IHeaderCellComp, ctrl: HeaderCellCtrl): ResizeFeature;
+    createGroupResizeFeature(comp: IHeaderGroupCellComp, eResize: HTMLElement, pinned: ColumnPinnedType, columnGroup: AgColumnGroup): GroupResizeFeature;
+}

package/dist/types/src/columnResize/groupResizeFeature.d.ts

@@ -0,0 +1,40 @@
+import { BeanStub } from '../context/beanStub';
+import type { AgColumn } from '../entities/agColumn';
+import type { AgColumnGroup } from '../entities/agColumnGroup';
+import type { ColumnEventType } from '../events';
+import type { IHeaderResizeFeature } from '../headerRendering/cells/abstractCell/abstractHeaderCellCtrl';
+import type { IHeaderGroupCellComp } from '../headerRendering/cells/columnGroup/headerGroupCellCtrl';
+import type { ColumnPinnedType } from '../interfaces/iColumn';
+interface ColumnSizeAndRatios {
+    columnsToResize: AgColumn[];
+    resizeStartWidth: number;
+    resizeRatios: number[];
+    groupAfterColumns?: AgColumn[];
+    groupAfterStartWidth?: number;
+    groupAfterRatios?: number[];
+}
+export declare class GroupResizeFeature extends BeanStub implements IHeaderResizeFeature {
+    private comp;
+    private eResize;
+    private pinned;
+    private columnGroup;
+    private resizeCols?;
+    private resizeStartWidth;
+    private resizeRatios?;
+    private resizeTakeFromCols?;
+    private resizeTakeFromStartWidth?;
+    private resizeTakeFromRatios?;
+    constructor(comp: IHeaderGroupCellComp, eResize: HTMLElement, pinned: ColumnPinnedType, columnGroup: AgColumnGroup);
+    postConstruct(): void;
+    private onResizeStart;
+    onResizing(finished: boolean, resizeAmount: any, source?: ColumnEventType): void;
+    getInitialValues(shiftKey?: boolean): ColumnSizeAndRatios;
+    resizeLeafColumnsToFit(source: ColumnEventType): void;
+    private resizeColumnsFromLocalValues;
+    resizeColumns(initialValues: ColumnSizeAndRatios, totalWidth: number, source: ColumnEventType, finished?: boolean): void;
+    toggleColumnResizing(resizing: boolean): void;
+    private getColumnsToResize;
+    private normaliseDragChange;
+    destroy(): void;
+}
+export {};

package/dist/types/src/columnResize/resizeFeature.d.ts

@@ -0,0 +1,21 @@
+import { BeanStub } from '../context/beanStub';
+import type { AgColumn } from '../entities/agColumn';
+import type { IHeaderResizeFeature } from '../headerRendering/cells/abstractCell/abstractHeaderCellCtrl';
+import type { HeaderCellCtrl, IHeaderCellComp } from '../headerRendering/cells/column/headerCellCtrl';
+import type { ColumnPinnedType } from '../interfaces/iColumn';
+export declare class ResizeFeature extends BeanStub implements IHeaderResizeFeature {
+    private pinned;
+    private column;
+    private eResize;
+    private comp;
+    private ctrl;
+    private lastResizeAmount;
+    private resizeStartWidth;
+    private resizeWithShiftKey;
+    constructor(pinned: ColumnPinnedType, column: AgColumn, eResize: HTMLElement, comp: IHeaderCellComp, ctrl: HeaderCellCtrl);
+    postConstruct(): void;
+    private onResizing;
+    private onResizeStart;
+    toggleColumnResizing(resizing: boolean): void;
+    private normaliseResizeAmount;
+}

package/dist/types/src/columns/baseColsService.d.ts

@@ -0,0 +1,43 @@
+import { BeanStub } from '../context/beanStub';
+import type { BeanCollection } from '../context/context';
+import type { AgColumn } from '../entities/agColumn';
+import type { ColumnEventType } from '../events';
+import type { IAggFuncService } from '../interfaces/iAggFuncService';
+import type { ColumnExtractors, ColumnOrdering, ColumnProcessor, ColumnProcessors, IColsService } from '../interfaces/iColsService';
+import type { ColumnChangedEventType } from './columnApi';
+import { dispatchColumnChangedEvent } from './columnEventUtils';
+import type { ColKey, ColumnModel, Maybe } from './columnModel';
+import type { ColumnState, ColumnStateParams } from './columnStateUtils';
+import type { VisibleColsService } from './visibleColsService';
+export declare abstract class BaseColsService extends BeanStub implements IColsService {
+    protected colModel: ColumnModel;
+    protected aggFuncSvc?: IAggFuncService;
+    protected visibleCols: VisibleColsService;
+    protected dispatchColumnChangedEvent: typeof dispatchColumnChangedEvent;
+    abstract eventName: ColumnChangedEventType;
+    abstract columnProcessors: ColumnProcessors;
+    abstract columnExtractors: ColumnExtractors;
+    columnOrdering: ColumnOrdering;
+    columns: AgColumn[];
+    wireBeans(beans: BeanCollection): void;
+    sortColumns(compareFn?: (a: AgColumn, b: AgColumn) => number): void;
+    setColumns(colKeys: ColKey[] | undefined, source: ColumnEventType): void;
+    addColumns(colKeys: ColKey[] | undefined, source: ColumnEventType): void;
+    removeColumns(colKeys: ColKey[] | undefined, source: ColumnEventType): void;
+    protected setColList(colKeys: ColKey[] | undefined, masterList: AgColumn[], eventName: IColsService['eventName'], detectOrderChange: boolean, autoGroupsNeedBuilding: boolean, columnCallback: ColumnProcessor, source: ColumnEventType): void;
+    protected updateColList(keys: Maybe<ColKey>[] | undefined, masterList: AgColumn[], actionIsAdd: boolean, autoGroupsNeedBuilding: boolean, columnCallback: ColumnProcessor, eventType: IColsService['eventName'], source: ColumnEventType): void;
+    extractCols(source: ColumnEventType, oldProvidedCols?: AgColumn[]): AgColumn[];
+    abstract syncColumnWithState(column: AgColumn, source: ColumnEventType, getValue: <U extends keyof ColumnStateParams, S extends keyof ColumnStateParams>(key1: U, key2?: S) => {
+        value1: ColumnStateParams[U] | undefined;
+        value2: ColumnStateParams[S] | undefined;
+    }, rowIndex: {
+        [key: string]: number;
+    } | null): void;
+    restoreColumnOrder(columnStateAccumulator: {
+        [colId: string]: ColumnState;
+    }, incomingColumnState: {
+        [colId: string]: ColumnState;
+    }): {
+        [colId: string]: ColumnState;
+    };
+}

package/dist/types/src/columns/columnApi.d.ts

@@ -0,0 +1,26 @@
+import type { BeanCollection } from '../context/context';
+import type { ColDef, ColGroupDef, HeaderLocation } from '../entities/colDef';
+import type { Column, ColumnPinnedType } from '../interfaces/iColumn';
+import type { ApplyColumnStateParams, ColumnState } from './columnStateUtils';
+export type ColumnChangedEventType = 'columnValueChanged' | 'columnPivotChanged' | 'columnRowGroupChanged';
+export declare function getColumnDef<TValue = any, TData = any>(beans: BeanCollection, key: string | Column<TValue>): ColDef<TData, TValue> | null;
+export declare function getColumnDefs<TData = any>(beans: BeanCollection): (ColDef<TData> | ColGroupDef<TData>)[] | undefined;
+export declare function getDisplayNameForColumn(beans: BeanCollection, column: Column, location: HeaderLocation): string;
+export declare function getColumn<TValue = any, TData = any>(beans: BeanCollection, key: string | ColDef<TData, TValue> | Column<TValue>): Column<TValue> | null;
+export declare function getColumns(beans: BeanCollection): Column[] | null;
+export declare function applyColumnState(beans: BeanCollection, params: ApplyColumnStateParams): boolean;
+export declare function getColumnState(beans: BeanCollection): ColumnState[];
+export declare function resetColumnState(beans: BeanCollection): void;
+export declare function isPinning(beans: BeanCollection): boolean;
+export declare function isPinningLeft(beans: BeanCollection): boolean;
+export declare function isPinningRight(beans: BeanCollection): boolean;
+export declare function getDisplayedColAfter(beans: BeanCollection, col: Column): Column | null;
+export declare function getDisplayedColBefore(beans: BeanCollection, col: Column): Column | null;
+export declare function setColumnsVisible(beans: BeanCollection, keys: (string | Column)[], visible: boolean): void;
+export declare function setColumnsPinned(beans: BeanCollection, keys: (string | ColDef | Column)[], pinned: ColumnPinnedType): void;
+export declare function getAllGridColumns(beans: BeanCollection): Column[];
+export declare function getDisplayedLeftColumns(beans: BeanCollection): Column[];
+export declare function getDisplayedCenterColumns(beans: BeanCollection): Column[];
+export declare function getDisplayedRightColumns(beans: BeanCollection): Column[];
+export declare function getAllDisplayedColumns(beans: BeanCollection): Column[];
+export declare function getAllDisplayedVirtualColumns(beans: BeanCollection): Column[];

package/dist/types/src/columns/columnDefFactory.d.ts

@@ -0,0 +1,16 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { BeanCollection } from '../context/context';
+import type { AgColumn } from '../entities/agColumn';
+import type { ColDef, ColGroupDef } from '../entities/colDef';
+export declare function _deepCloneDefinition<T>(object: T, keysToSkip?: string[]): T | undefined;
+export declare class ColumnDefFactory extends BeanStub implements NamedBean {
+    beanName: "colDefFactory";
+    private rowGroupColsSvc?;
+    private pivotColsSvc?;
+    wireBeans(beans: BeanCollection): void;
+    getColumnDefs(colDefColsList: AgColumn[], showingPivotResult: boolean, lastOrder: AgColumn[] | null, colsList: AgColumn[]): (ColDef | ColGroupDef)[] | undefined;
+    private buildColumnDefs;
+    private createDefFromGroup;
+    private createDefFromColumn;
+}

package/dist/types/src/columns/columnEventUtils.d.ts

@@ -0,0 +1,7 @@
+import type { AgColumn } from '../entities/agColumn';
+import type { EventService } from '../eventService';
+import type { ColumnEventType } from '../events';
+export declare function dispatchColumnPinnedEvent(eventSvc: EventService, changedColumns: AgColumn[], source: ColumnEventType): void;
+export declare function dispatchColumnVisibleEvent(eventSvc: EventService, changedColumns: AgColumn[], source: ColumnEventType): void;
+export declare function dispatchColumnChangedEvent<T extends 'columnValueChanged' | 'columnPivotChanged' | 'columnRowGroupChanged'>(eventSvc: EventService, type: T, columns: AgColumn[], source: ColumnEventType): void;
+export declare function dispatchColumnResizedEvent(eventSvc: EventService, columns: AgColumn[] | null, finished: boolean, source: ColumnEventType, flexColumns?: AgColumn[] | null): void;

package/dist/types/src/columns/columnFactoryUtils.d.ts

@@ -0,0 +1,16 @@
+import type { BeanCollection } from '../context/context';
+import { AgColumn } from '../entities/agColumn';
+import type { AgProvidedColumnGroup } from '../entities/agProvidedColumnGroup';
+import type { ColDef, ColGroupDef, SortDirection } from '../entities/colDef';
+import type { ColumnEventType } from '../events';
+import { ColumnKeyCreator } from './columnKeyCreator';
+export declare function _createColumnTree(beans: BeanCollection, defs: (ColDef<any, any> | ColGroupDef<any>)[] | null | undefined, primaryColumns: boolean, existingTree: (AgColumn | AgProvidedColumnGroup)[] | undefined, source: ColumnEventType): {
+    columnTree: (AgColumn | AgProvidedColumnGroup)[];
+    treeDept: number;
+};
+export declare function _recursivelyCreateColumns(beans: BeanCollection, defs: (ColDef | ColGroupDef)[] | null, level: number, primaryColumns: boolean, existingColsCopy: AgColumn[], columnKeyCreator: ColumnKeyCreator, existingGroups: AgProvidedColumnGroup[], source: ColumnEventType): (AgColumn | AgProvidedColumnGroup)[];
+/** Updates hide, sort, sortIndex, pinned and flex */
+export declare function updateSomeColumnState(beans: BeanCollection, column: AgColumn, hide: boolean | null | undefined, sort: SortDirection | undefined, sortIndex: number | null | undefined, pinned: boolean | 'left' | 'right' | null | undefined, flex: number | null | undefined, source: ColumnEventType): void;
+export declare function _updateColumnState(beans: BeanCollection, column: AgColumn, colDef: ColDef, source: ColumnEventType): void;
+export declare function _addColumnDefaultAndTypes(beans: BeanCollection, colDef: ColDef, colId: string, isAutoCol?: boolean): ColDef;
+export declare function depthFirstOriginalTreeSearch(parent: AgProvidedColumnGroup | null, tree: (AgColumn | AgProvidedColumnGroup)[], callback: (treeNode: AgColumn | AgProvidedColumnGroup, parent: AgProvidedColumnGroup | null) => void): void;

package/dist/types/src/columns/columnFlexService.d.ts

@@ -0,0 +1,18 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { AgColumn } from '../entities/agColumn';
+import type { ColumnEventType } from '../events';
+export declare class ColumnFlexService extends BeanStub implements NamedBean {
+    beanName: "colFlex";
+    private flexViewportWidth;
+    refreshFlexedColumns(params?: {
+        resizingCols?: AgColumn[];
+        skipSetLeft?: boolean;
+        viewportWidth?: number;
+        source?: ColumnEventType;
+        fireResizedEvent?: boolean;
+        updateBodyWidths?: boolean;
+    }): AgColumn[];
+    initCol(column: AgColumn): void;
+    setColFlex(column: AgColumn, flex: number | null): void;
+}

package/dist/types/src/columns/columnGroups/columnGroupApi.d.ts

@@ -0,0 +1,20 @@
+import type { BeanCollection } from '../../context/context';
+import type { HeaderLocation } from '../../entities/colDef';
+import type { Column, ColumnGroup, ProvidedColumnGroup } from '../../interfaces/iColumn';
+export declare function setColumnGroupOpened(beans: BeanCollection, group: ProvidedColumnGroup | string, newValue: boolean): void;
+export declare function getColumnGroup(beans: BeanCollection, name: string, instanceId?: number): ColumnGroup | null;
+export declare function getProvidedColumnGroup(beans: BeanCollection, name: string): ProvidedColumnGroup | null;
+export declare function getDisplayNameForColumnGroup(beans: BeanCollection, columnGroup: ColumnGroup, location: HeaderLocation): string;
+export declare function getColumnGroupState(beans: BeanCollection): {
+    groupId: string;
+    open: boolean;
+}[];
+export declare function setColumnGroupState(beans: BeanCollection, stateItems: {
+    groupId: string;
+    open: boolean;
+}[]): void;
+export declare function resetColumnGroupState(beans: BeanCollection): void;
+export declare function getLeftDisplayedColumnGroups(beans: BeanCollection): (Column | ColumnGroup)[];
+export declare function getCenterDisplayedColumnGroups(beans: BeanCollection): (Column | ColumnGroup)[];
+export declare function getRightDisplayedColumnGroups(beans: BeanCollection): (Column | ColumnGroup)[];
+export declare function getAllDisplayedColumnGroups(beans: BeanCollection): (Column | ColumnGroup)[] | null;

package/dist/types/src/columns/columnGroups/columnGroupModule.d.ts

@@ -0,0 +1,7 @@
+import type { _ColumnGroupGridApi } from '../../api/gridApi';
+import type { _ModuleWithApi } from '../../interfaces/iModule';
+/**
+ * @feature Columns -> Column Groups
+ * @colGroupDef
+ */
+export declare const ColumnGroupModule: _ModuleWithApi<_ColumnGroupGridApi>;

package/dist/types/src/columns/columnGroups/columnGroupService.d.ts

@@ -0,0 +1,51 @@
+import type { NamedBean } from '../../context/bean';
+import { BeanStub } from '../../context/beanStub';
+import type { AgColumn } from '../../entities/agColumn';
+import { AgColumnGroup } from '../../entities/agColumnGroup';
+import { AgProvidedColumnGroup } from '../../entities/agProvidedColumnGroup';
+import type { ColGroupDef } from '../../entities/colDef';
+import type { ColumnEventType } from '../../events';
+import type { ColumnPinnedType } from '../../interfaces/iColumn';
+import type { ColumnKeyCreator } from '../columnKeyCreator';
+import type { GroupInstanceIdCreator } from '../groupInstanceIdCreator';
+export interface CreateGroupsParams {
+    columns: AgColumn[];
+    idCreator: GroupInstanceIdCreator;
+    pinned: ColumnPinnedType;
+    oldDisplayedGroups?: (AgColumn | AgColumnGroup)[];
+    isStandaloneStructure?: boolean;
+}
+export declare class ColumnGroupService extends BeanStub implements NamedBean {
+    beanName: "colGroupSvc";
+    getColumnGroupState(): {
+        groupId: string;
+        open: boolean;
+    }[];
+    resetColumnGroupState(source: ColumnEventType): void;
+    setColumnGroupState(stateItems: {
+        groupId: string;
+        open: boolean | undefined;
+    }[], source: ColumnEventType): void;
+    setColumnGroupOpened(key: AgProvidedColumnGroup | string | null, newValue: boolean, source: ColumnEventType): void;
+    getProvidedColGroup(key: string): AgProvidedColumnGroup | null;
+    getGroupAtDirection(columnGroup: AgColumnGroup, direction: 'After' | 'Before'): AgColumnGroup | null;
+    getColGroupAtLevel(column: AgColumn, level: number): AgColumnGroup | null;
+    updateOpenClosedVisibility(): void;
+    getColumnGroup(colId: string | AgColumnGroup, partId?: number): AgColumnGroup | null;
+    createColumnGroups(params: CreateGroupsParams): (AgColumn | AgColumnGroup)[];
+    createProvidedColumnGroup(primaryColumns: boolean, colGroupDef: ColGroupDef, level: number, existingColumns: AgColumn[], columnKeyCreator: ColumnKeyCreator, existingGroups: AgProvidedColumnGroup[], source: ColumnEventType): AgProvidedColumnGroup;
+    balanceColumnTree(unbalancedTree: (AgColumn | AgProvidedColumnGroup)[], currentDept: number, columnDept: number, columnKeyCreator: ColumnKeyCreator): (AgColumn | AgProvidedColumnGroup)[];
+    findDepth(balancedColumnTree: (AgColumn | AgProvidedColumnGroup)[]): number;
+    findMaxDepth(treeChildren: (AgColumn | AgProvidedColumnGroup)[], depth: number): number;
+    /**
+     * Inserts dummy group columns in the hierarchy above auto-generated columns
+     * in order to ensure auto-generated columns are leaf nodes (and therefore are
+     * displayed correctly)
+     */
+    balanceTreeForAutoCols(autoCols: AgColumn[], depth: number): (AgColumn | AgProvidedColumnGroup)[];
+    private createMergedColGroupDef;
+    private findExistingGroup;
+    private createColumnGroup;
+    private mapOldGroupsById;
+    private setupParentsIntoCols;
+}

package/dist/types/src/columns/columnHover/columnHoverApi.d.ts

@@ -0,0 +1,3 @@
+import type { BeanCollection } from '../../context/context';
+import type { Column } from '../../interfaces/iColumn';
+export declare function isColumnHovered(beans: BeanCollection, column: Column): boolean;

package/dist/types/src/columns/columnHover/columnHoverModule.d.ts

@@ -0,0 +1,7 @@
+import type { _ColumnHoverApi } from '../../api/gridApi';
+import type { _ModuleWithApi } from '../../interfaces/iModule';
+/**
+ * @feature Rows -> Styling Rows
+ * @gridOption columnHoverHighlight
+ */
+export declare const ColumnHoverModule: _ModuleWithApi<_ColumnHoverApi>;

package/dist/types/src/columns/columnHover/columnHoverService.d.ts

@@ -0,0 +1,18 @@
+import type { NamedBean } from '../../context/bean';
+import { BeanStub } from '../../context/beanStub';
+import type { AgColumn } from '../../entities/agColumn';
+import type { IHeaderCellComp } from '../../headerRendering/cells/column/headerCellCtrl';
+import type { IHeaderFilterCellComp } from '../../headerRendering/cells/floatingFilter/iHeaderFilterCellComp';
+import type { ICellComp } from '../../rendering/cell/cellCtrl';
+export declare class ColumnHoverService extends BeanStub implements NamedBean {
+    beanName: "colHover";
+    private selectedColumns;
+    setMouseOver(columns: AgColumn[]): void;
+    clearMouseOver(): void;
+    isHovered(column: AgColumn): boolean;
+    addHeaderColumnHoverListener(compBean: BeanStub, comp: IHeaderCellComp, column: AgColumn): void;
+    onCellColumnHover(column: AgColumn, cellComp?: ICellComp): void;
+    addHeaderFilterColumnHoverListener(compBean: BeanStub, comp: IHeaderFilterCellComp, column: AgColumn, eGui: HTMLElement): void;
+    createHoverFeature(compBean: BeanStub, columns: AgColumn[], eGui: HTMLElement): void;
+    private updateState;
+}

package/dist/types/src/columns/columnHover/hoverFeature.d.ts

@@ -0,0 +1,8 @@
+import { BeanStub } from '../../context/beanStub';
+import type { AgColumn } from '../../entities/agColumn';
+export declare class HoverFeature extends BeanStub {
+    private readonly columns;
+    private readonly element;
+    constructor(columns: AgColumn[], element: HTMLElement);
+    postConstruct(): void;
+}

package/dist/types/src/columns/columnModel.d.ts

@@ -0,0 +1,57 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { AgColumn } from '../entities/agColumn';
+import type { AgProvidedColumnGroup } from '../entities/agProvidedColumnGroup';
+import type { ColDef, ColGroupDef } from '../entities/colDef';
+import type { ColumnEventType } from '../events';
+import type { Column } from '../interfaces/iColumn';
+export type ColKey<TData = any, TValue = any> = string | ColDef<TData, TValue> | Column<TValue>;
+export type Maybe<T> = T | null | undefined;
+export interface ColumnCollections {
+    tree: (AgColumn | AgProvidedColumnGroup)[];
+    treeDepth: number;
+    list: AgColumn[];
+    map: {
+        [id: string]: AgColumn;
+    };
+}
+export declare class ColumnModel extends BeanStub implements NamedBean {
+    beanName: "colModel";
+    private colDefs?;
+    colDefCols?: ColumnCollections;
+    cols?: ColumnCollections;
+    private pivotMode;
+    private showingPivotResult;
+    private lastOrder;
+    private lastPivotOrder;
+    colSpanActive: boolean;
+    ready: boolean;
+    changeEventsDispatching: boolean;
+    postConstruct(): void;
+    private createColsFromColDefs;
+    refreshCols(newColDefs: boolean): void;
+    private selectCols;
+    getColsToShow(): AgColumn[];
+    refreshAll(source: ColumnEventType): void;
+    setColsVisible(keys: (string | AgColumn)[], visible: boolean | undefined, source: ColumnEventType): void;
+    private restoreColOrder;
+    private positionLockedCols;
+    private saveColOrder;
+    getColumnDefs(): (ColDef | ColGroupDef)[] | undefined;
+    private setColSpanActive;
+    isPivotMode(): boolean;
+    private setPivotMode;
+    isPivotActive(): boolean;
+    recreateColumnDefs(source: ColumnEventType): void;
+    setColumnDefs(columnDefs: (ColDef | ColGroupDef)[], source: ColumnEventType): void;
+    destroy(): void;
+    getColTree(): (AgColumn | AgProvidedColumnGroup)[];
+    getColDefColTree(): (AgColumn | AgProvidedColumnGroup)[];
+    getColDefCols(): AgColumn[] | null;
+    getCols(): AgColumn[];
+    getAllCols(): AgColumn[];
+    getColsForKeys(keys: ColKey[]): AgColumn[];
+    getColDefCol(key: ColKey): AgColumn | null;
+    getCol(key: Maybe<ColKey>): AgColumn | null;
+    getColFromCollection(key: ColKey, cols?: ColumnCollections): AgColumn | null;
+}

package/dist/types/src/columns/columnModule.d.ts

@@ -0,0 +1,14 @@
+import type { _ColumnGridApi } from '../api/gridApi';
+import type { _ModuleWithApi, _ModuleWithoutApi } from '../interfaces/iModule';
+/**
+ * @internal
+ */
+export declare const DataTypeModule: _ModuleWithoutApi;
+/**
+ * @internal
+ */
+export declare const ColumnFlexModule: _ModuleWithoutApi;
+/**
+ * @feature Columns
+ */
+export declare const ColumnApiModule: _ModuleWithApi<_ColumnGridApi<any>>;

package/dist/types/src/columns/columnNameService.d.ts

@@ -0,0 +1,19 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { AgColumn } from '../entities/agColumn';
+import type { AgColumnGroup } from '../entities/agColumnGroup';
+import type { AgProvidedColumnGroup } from '../entities/agProvidedColumnGroup';
+import type { HeaderLocation } from '../entities/colDef';
+/**
+ * Converts a camelCase string into startCase
+ * @param {string} camelCase
+ * @return {string}
+ */
+export declare function _camelCaseToHumanText(camelCase: string | undefined): string | null;
+export declare class ColumnNameService extends BeanStub implements NamedBean {
+    beanName: "colNames";
+    getDisplayNameForColumn(column: AgColumn | null, location: HeaderLocation, includeAggFunc?: boolean): string | null;
+    getDisplayNameForProvidedColumnGroup(columnGroup: AgColumnGroup | null, providedColumnGroup: AgProvidedColumnGroup | null, location: HeaderLocation): string | null;
+    getDisplayNameForColumnGroup(columnGroup: AgColumnGroup, location: HeaderLocation): string | null;
+    private getHeaderName;
+}

package/dist/types/src/columns/columnStateUtils.d.ts

@@ -0,0 +1,59 @@
+import type { BeanCollection } from '../context/context';
+import type { AgColumn } from '../entities/agColumn';
+import type { IAggFunc } from '../entities/colDef';
+import type { ColumnEventType } from '../events';
+import type { ColumnPinnedType } from '../interfaces/iColumn';
+export interface ModifyColumnsNoEventsCallbacks {
+    addGroupCol(col: AgColumn): void;
+    removeGroupCol(col: AgColumn): void;
+    addPivotCol(col: AgColumn): void;
+    removePivotCol(col: AgColumn): void;
+    addValueCol(col: AgColumn): void;
+    removeValueCol(col: AgColumn): void;
+}
+export interface ColumnStateParams {
+    /** True if the column is hidden */
+    hide?: boolean | null;
+    /** Width of the column in pixels */
+    width?: number;
+    /** Column's flex if flex is set */
+    flex?: number | null;
+    /** Sort applied to the column */
+    sort?: 'asc' | 'desc' | null;
+    /** The order of the sort, if sorting by many columns */
+    sortIndex?: number | null;
+    /** The aggregation function applied */
+    aggFunc?: string | IAggFunc | null;
+    /** True if pivot active */
+    pivot?: boolean | null;
+    /** The order of the pivot, if pivoting by many columns */
+    pivotIndex?: number | null;
+    /** Set if column is pinned */
+    pinned?: ColumnPinnedType;
+    /** True if row group active */
+    rowGroup?: boolean | null;
+    /** The order of the row group, if grouping by many columns */
+    rowGroupIndex?: number | null;
+}
+export interface ColumnState extends ColumnStateParams {
+    /** ID of the column */
+    colId: string;
+}
+export interface ApplyColumnStateParams {
+    /** The state from `getColumnState` */
+    state?: ColumnState[];
+    /** Whether column order should be applied */
+    applyOrder?: boolean;
+    /** State to apply to columns where state is missing for those columns */
+    defaultState?: ColumnStateParams;
+}
+export declare function _applyColumnState(beans: BeanCollection, params: ApplyColumnStateParams, source: ColumnEventType): boolean;
+export declare function _resetColumnState(beans: BeanCollection, source: ColumnEventType): void;
+/**
+ * calculates what events to fire between column state changes. gets used when:
+ * a) apply column state
+ * b) apply new column definitions (so changes from old cols)
+ */
+export declare function _compareColumnStatesAndDispatchEvents(beans: BeanCollection, source: ColumnEventType): () => void;
+export declare function _getColumnState(beans: BeanCollection): ColumnState[];
+export declare function getColumnStateFromColDef(column: AgColumn): ColumnState;

package/dist/types/src/columns/columnUtils.d.ts

@@ -0,0 +1,22 @@
+import type { BeanCollection } from '../context/context';
+import type { AgColumn } from '../entities/agColumn';
+import type { AgProvidedColumnGroup } from '../entities/agProvidedColumnGroup';
+import type { ColumnEventType } from '../events';
+import type { PropertyChangedSource } from '../gridOptionsService';
+import type { ColKey, ColumnCollections } from './columnModel';
+import type { ColumnState, ColumnStateParams } from './columnStateUtils';
+export declare const GROUP_AUTO_COLUMN_ID: "ag-Grid-AutoColumn";
+export declare function _getColumnsFromTree(rootColumns: (AgColumn | AgProvidedColumnGroup)[]): AgColumn[];
+export declare function getWidthOfColsInList(columnList: AgColumn[]): number;
+export declare function _destroyColumnTree(beans: BeanCollection, oldTree: (AgColumn | AgProvidedColumnGroup)[] | null | undefined, newTree?: (AgColumn | AgProvidedColumnGroup)[] | null): void;
+export declare function isColumnGroupAutoCol(col: AgColumn): boolean;
+export declare function isColumnSelectionCol(col: ColKey): boolean;
+export declare function convertColumnTypes(type: string | string[]): string[];
+export declare function _areColIdsEqual(colsA: AgColumn[] | null, colsB: AgColumn[] | null): boolean;
+export declare function _updateColsMap(cols: ColumnCollections): void;
+export declare function _convertColumnEventSourceType(source: PropertyChangedSource): ColumnEventType;
+export declare function _columnsMatch(column: AgColumn, key: ColKey): boolean;
+export declare const getValueFactory: (stateItem: ColumnState | null, defaultState: ColumnStateParams | undefined) => <U extends keyof ColumnStateParams, S extends keyof ColumnStateParams>(key1: U, key2?: S | undefined) => {
+    value1: ColumnStateParams[U] | undefined;
+    value2: ColumnStateParams[S] | undefined;
+};

package/dist/types/src/columns/columnViewportService.d.ts

@@ -0,0 +1,37 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { BeanCollection } from '../context/context';
+import type { AgColumn } from '../entities/agColumn';
+import type { AgColumnGroup } from '../entities/agColumnGroup';
+import type { RowNode } from '../entities/rowNode';
+import type { ColumnPinnedType } from '../interfaces/iColumn';
+export declare class ColumnViewportService extends BeanStub implements NamedBean {
+    beanName: "colViewport";
+    private visibleCols;
+    private colModel;
+    wireBeans(beans: BeanCollection): void;
+    private colsWithinViewport;
+    private headerColsWithinViewport;
+    private colsWithinViewportHash;
+    private rowsOfHeadersToRenderLeft;
+    private rowsOfHeadersToRenderRight;
+    private rowsOfHeadersToRenderCenter;
+    private scrollWidth;
+    private scrollPosition;
+    private viewportLeft;
+    private viewportRight;
+    private suppressColumnVirtualisation;
+    postConstruct(): void;
+    setScrollPosition(scrollWidth: number, scrollPosition: number, afterScroll?: boolean): void;
+    getHeadersToRender(type: ColumnPinnedType, dept: number): (AgColumn | AgColumnGroup)[];
+    private extractViewportColumns;
+    private isColumnVirtualisationSuppressed;
+    clear(suppressHashClear?: boolean): void;
+    private isColumnInHeaderViewport;
+    private isColumnInRowViewport;
+    getViewportColumns(): AgColumn[];
+    getColsWithinViewport(rowNode: RowNode): AgColumn[];
+    checkViewportColumns(afterScroll?: boolean): void;
+    private calculateHeaderRows;
+    private extractViewport;
+}

package/dist/types/src/columns/dataTypeService.d.ts

@@ -0,0 +1,47 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { BeanCollection } from '../context/context';
+import type { AgColumn } from '../entities/agColumn';
+import type { ColDef } from '../entities/colDef';
+import type { BaseCellDataType, CoreDataTypeDefinition, DataTypeDefinition, DataTypeFormatValueFunc } from '../entities/dataType';
+export declare class DataTypeService extends BeanStub implements NamedBean {
+    beanName: "dataTypeSvc";
+    private colModel;
+    wireBeans(beans: BeanCollection): void;
+    private dataTypeDefinitions;
+    private dataTypeMatchers;
+    private formatValueFuncs;
+    isPendingInference: boolean;
+    private hasObjectValueParser;
+    private hasObjectValueFormatter;
+    private initialData;
+    private isColumnTypeOverrideInDataTypeDefinitions;
+    private columnStateUpdatesPendingInference;
+    private columnStateUpdateListenerDestroyFuncs;
+    postConstruct(): void;
+    private processDataTypeDefinitions;
+    private processDataTypeDefinition;
+    updateColDefAndGetColumnType(colDef: ColDef, userColDef: ColDef, colId: string): string | string[] | undefined;
+    addColumnListeners(column: AgColumn): void;
+    private canInferCellDataType;
+    private inferCellDataType;
+    private getInitialData;
+    private initWaitForRowData;
+    private processColumnsPendingInference;
+    private generateColumnStateForRowGroupAndPivotIndexes;
+    private resetColDefIntoCol;
+    private checkObjectValueHandlers;
+    private getDateStringTypeDefinition;
+    getDateParserFunction(column?: AgColumn | null): (value: string | undefined) => Date | undefined;
+    getDateFormatterFunction(column?: AgColumn | null): (value: Date | undefined) => string | undefined;
+    getDataTypeDefinition(column: AgColumn): DataTypeDefinition | CoreDataTypeDefinition | undefined;
+    getBaseDataType(column: AgColumn): BaseCellDataType | undefined;
+    checkType(column: AgColumn, value: any): boolean;
+    validateColDef(colDef: ColDef): void;
+    getFormatValue(cellDataType: string): DataTypeFormatValueFunc | undefined;
+    isColPendingInference(colId: string): boolean;
+    private setColDefPropertiesForBaseDataType;
+    private getDefaultDataTypes;
+    private destroyColumnStateUpdateListeners;
+    destroy(): void;
+}