ag-grid-community 32.3.2 → 33.0.0

package/dist/types/src/api/gridApiFunctions.d.ts

@@ -0,0 +1,3 @@
+import type { ValidationModuleName } from '../interfaces/iModule';
+import type { GridApi } from './gridApi';
+export declare const gridApiFunctionsMap: Record<keyof GridApi, ValidationModuleName>;

package/dist/types/src/api/rowApi.d.ts

@@ -0,0 +1,14 @@
+import type { BeanCollection } from '../context/context';
+import type { RenderedRowEvent } from '../interfaces/iCallbackParams';
+import type { RedrawRowsParams } from '../interfaces/iRedrawRowsParams';
+import type { IRowNode } from '../interfaces/iRowNode';
+export declare function redrawRows<TData = any>(beans: BeanCollection, params?: RedrawRowsParams<TData>): void;
+export declare function setRowNodeExpanded(beans: BeanCollection, rowNode: IRowNode, expanded: boolean, expandParents?: boolean, forceSync?: boolean): void;
+export declare function getRowNode<TData = any>(beans: BeanCollection, id: string): IRowNode<TData> | undefined;
+export declare function addRenderedRowListener(beans: BeanCollection, eventName: RenderedRowEvent, rowIndex: number, callback: (...args: any[]) => any): void;
+export declare function getRenderedNodes<TData = any>(beans: BeanCollection): IRowNode<TData>[];
+export declare function forEachNode<TData = any>(beans: BeanCollection, callback: (rowNode: IRowNode<TData>, index: number) => void, includeFooterNodes?: boolean): void;
+export declare function getFirstDisplayedRowIndex(beans: BeanCollection): number;
+export declare function getLastDisplayedRowIndex(beans: BeanCollection): number;
+export declare function getDisplayedRowAtIndex<TData = any>(beans: BeanCollection, index: number): IRowNode<TData> | undefined;
+export declare function getDisplayedRowCount(beans: BeanCollection): number;

package/dist/types/src/api/rowModelApiUtils.d.ts

@@ -0,0 +1,7 @@
+import type { BeanCollection } from '../context/context';
+import type { InfiniteRowModel } from '../infiniteRowModel/infiniteRowModel';
+import type { IClientSideRowModel } from '../interfaces/iClientSideRowModel';
+import type { IServerSideRowModel } from '../interfaces/iServerSideRowModel';
+export declare function _getClientSideRowModel(beans: BeanCollection): IClientSideRowModel | undefined;
+export declare function _getInfiniteRowModel(beans: BeanCollection): InfiniteRowModel | undefined;
+export declare function _getServerSideRowModel(beans: BeanCollection): IServerSideRowModel | undefined;

package/dist/types/src/api/sharedApiModule.d.ts

@@ -0,0 +1,10 @@
+import type { _ModuleWithApi } from '../interfaces/iModule';
+import type { _CsrmSsrmSharedGridApi, _SsrmInfiniteSharedGridApi } from './gridApi';
+/**
+ * @internal
+ */
+export declare const CsrmSsrmSharedApiModule: _ModuleWithApi<_CsrmSsrmSharedGridApi>;
+/**
+ * @internal
+ */
+export declare const SsrmInfiniteSharedApiModule: _ModuleWithApi<_SsrmInfiniteSharedGridApi>;

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

@@ -0,0 +1 @@
+export declare const BASE_URL = "https://www.ag-grid.com";

package/dist/types/src/clientSideRowModel/abstractClientSideNodeManager.d.ts

@@ -0,0 +1,62 @@
+import { BeanStub } from '../context/beanStub';
+import type { GetRowIdFunc } from '../entities/gridOptions';
+import { RowNode } from '../entities/rowNode';
+import type { ClientSideNodeManagerUpdateRowDataResult, IClientSideNodeManager } from '../interfaces/iClientSideNodeManager';
+import type { IChangedRowNodes, RefreshModelParams } from '../interfaces/iClientSideRowModel';
+import type { RowDataTransaction } from '../interfaces/rowDataTransaction';
+/**
+ * This is the type of any row in allLeafChildren and childrenAfterGroup of the ClientSideNodeManager rootNode.
+ * ClientSideNodeManager is allowed to update the sourceRowIndex property of the nodes.
+ */
+interface ClientSideNodeManagerRowNode<TData> extends RowNode<TData> {
+    sourceRowIndex: number;
+}
+/**
+ * This is the type of the root RowNode of the ClientSideNodeManager
+ * ClientSideNodeManager is allowed to update the allLeafChildren and childrenAfterGroup properties of the root node.
+ */
+interface ClientSideNodeManagerRootNode<TData> extends RowNode<TData> {
+    sibling: ClientSideNodeManagerRootNode<TData>;
+    allLeafChildren: ClientSideNodeManagerRowNode<TData>[] | null;
+    childrenAfterGroup: ClientSideNodeManagerRowNode<TData>[] | null;
+}
+export declare namespace AbstractClientSideNodeManager {
+    type RowNode<TData> = ClientSideNodeManagerRowNode<TData>;
+    type RootNode<TData> = ClientSideNodeManagerRootNode<TData>;
+}
+export declare abstract class AbstractClientSideNodeManager<TData = any> extends BeanStub implements IClientSideNodeManager<TData> {
+    private nextId;
+    protected allNodesMap: {
+        [id: string]: RowNode<TData>;
+    };
+    rootNode: AbstractClientSideNodeManager.RootNode<TData> | null;
+    get treeData(): boolean;
+    getRowNode(id: string): RowNode | undefined;
+    extractRowData(): TData[] | null | undefined;
+    activate(rootNode: ClientSideNodeManagerRootNode<TData>): void;
+    deactivate(): void;
+    destroy(): void;
+    setNewRowData(rowData: TData[]): void;
+    private updateRootSiblingArrays;
+    protected loadNewRowData(rowData: TData[]): void;
+    setImmutableRowData(params: RefreshModelParams<TData>, rowData: TData[]): void;
+    updateRowData(rowDataTran: RowDataTransaction<TData>, changedRowNodes: IChangedRowNodes<TData>): ClientSideNodeManagerUpdateRowDataResult<TData>;
+    /** Converts the setRowData() command to a transaction */
+    private createTransactionForRowData;
+    /**
+     * Used by setImmutableRowData, after updateRowData, after updating with a generated transaction to
+     * apply the order as specified by the the new data. We use sourceRowIndex to determine the order of the rows.
+     * Time complexity is O(n) where n is the number of rows/rowData
+     * @returns true if the order changed, otherwise false
+     */
+    private updateRowOrderFromRowData;
+    protected executeAdd(rowDataTran: RowDataTransaction, result: ClientSideNodeManagerUpdateRowDataResult<TData>): void;
+    protected executeRemove(getRowIdFunc: GetRowIdFunc<TData> | undefined, rowDataTran: RowDataTransaction, { changedRowNodes, rowNodeTransaction }: ClientSideNodeManagerUpdateRowDataResult<TData>, nodesToUnselect: RowNode<TData>[]): void;
+    protected executeUpdate(getRowIdFunc: GetRowIdFunc<TData> | undefined, rowDataTran: RowDataTransaction, { changedRowNodes, rowNodeTransaction }: ClientSideNodeManagerUpdateRowDataResult<TData>, nodesToUnselect: RowNode<TData>[]): void;
+    protected dispatchRowDataUpdateStartedEvent(rowData?: TData[] | null): void;
+    protected deselectNodes(nodesToUnselect: RowNode<TData>[]): void;
+    private sanitizeAddIndex;
+    protected createRowNode(data: TData, sourceRowIndex: number): RowNode<TData>;
+    protected lookupRowNode(getRowIdFunc: ((data: any) => string) | undefined, data: TData): RowNode<TData> | null;
+}
+export {};

package/dist/types/src/clientSideRowModel/changedRowNodes.d.ts

@@ -0,0 +1,13 @@
+import type { RowNode } from '../entities/rowNode';
+import type { IChangedRowNodes } from '../interfaces/iClientSideRowModel';
+import type { IRowNode } from '../interfaces/iRowNode';
+export declare class ChangedRowNodes<TData = any> implements IChangedRowNodes<TData> {
+    readonly removals: Set<RowNode<TData>>;
+    readonly updates: Map<RowNode<TData>, boolean>;
+    /** Marks a row as removed. Order of operations is: remove, update, add */
+    remove(node: IRowNode<TData>): void;
+    /** Marks a row as updated. Order of operations is: remove, update, add */
+    update(node: IRowNode<TData>): void;
+    /** Marks a row as added. Order of operation is: remove, update, add */
+    add(node: IRowNode<TData>): void;
+}

package/dist/types/src/clientSideRowModel/clientSideNodeManager.d.ts

@@ -0,0 +1,5 @@
+import type { NamedBean } from '../context/bean';
+import { AbstractClientSideNodeManager } from './abstractClientSideNodeManager';
+export declare class ClientSideNodeManager<TData> extends AbstractClientSideNodeManager<TData> implements NamedBean {
+    beanName: "csrmNodeSvc";
+}

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

@@ -0,0 +1,141 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { BeanCollection } from '../context/context';
+import type { RowHighlightPosition } from '../entities/rowNode';
+import { RowNode } from '../entities/rowNode';
+import type { IClientSideRowModel, RefreshModelParams } from '../interfaces/iClientSideRowModel';
+import type { RowBounds, RowModelType } from '../interfaces/iRowModel';
+import type { RowDataTransaction } from '../interfaces/rowDataTransaction';
+import type { RowNodeTransaction } from '../interfaces/rowNodeTransaction';
+import { ChangedPath } from '../utils/changedPath';
+export interface BatchTransactionItem<TData = any> {
+    rowDataTransaction: RowDataTransaction<TData>;
+    callback: ((res: RowNodeTransaction<TData>) => void) | undefined;
+}
+export interface RowNodeMap {
+    [id: string]: RowNode;
+}
+export declare class ClientSideRowModel extends BeanStub implements IClientSideRowModel, NamedBean {
+    beanName: "rowModel";
+    private colModel;
+    private valueCache?;
+    private filterStage?;
+    private sortStage?;
+    private flattenStage?;
+    private groupStage?;
+    private aggStage?;
+    private pivotStage?;
+    private filterAggStage?;
+    wireBeans(beans: BeanCollection): void;
+    private onRowHeightChanged_debounced;
+    rootNode: RowNode | null;
+    private rowsToDisplay;
+    private nodeManager;
+    private rowDataTransactionBatch;
+    private lastHighlightedRow;
+    private applyAsyncTransactionsTimeout;
+    /** Has the start method been called */
+    private started;
+    /** E.g. data has been set into the node manager already */
+    private shouldSkipSettingDataOnStart;
+    /**
+     * This is to prevent refresh model being called when it's already being called.
+     * E.g. the group stage can trigger initial state filter model to be applied. This fires onFilterChanged,
+     * which then triggers the listener here that calls refresh model again but at the filter stage
+     * (which is about to be run by the original call).
+     */
+    private isRefreshingModel;
+    private rowNodesCountReady;
+    private rowCountReady;
+    private orderedStages;
+    postConstruct(): void;
+    private initRowManager;
+    private addPropertyListeners;
+    start(): void;
+    private setInitialData;
+    ensureRowHeightsValid(startPixel: number, endPixel: number, startLimitIndex: number, endLimitIndex: number): boolean;
+    private onPropChange;
+    private setRowTopAndRowIndex;
+    private clearRowTopAndRowIndex;
+    ensureRowsAtPixel(rowNodes: RowNode[], pixel: number, increment?: number): boolean;
+    highlightRowAtPixel(rowNode: RowNode | null, pixel?: number): void;
+    private setRowNodeHighlighted;
+    getHighlightPosition(pixel: number, rowNode?: RowNode): RowHighlightPosition;
+    getLastHighlightedRowNode(): RowNode | null;
+    private isHighlightingCurrentPosition;
+    private clearHighlightedRow;
+    isLastRowIndexKnown(): boolean;
+    getRowCount(): number;
+    /**
+     * Returns the number of rows with level === 1
+     */
+    getTopLevelRowCount(): number;
+    /**
+     * Get the row display index by the top level index
+     * top level index is the index of rows with level === 1
+     */
+    getTopLevelRowDisplayedIndex(topLevelIndex: number): number;
+    getRowBounds(index: number): RowBounds | null;
+    onRowGroupOpened(): void;
+    private onFilterChanged;
+    private onSortChanged;
+    getType(): RowModelType;
+    private onValueChanged;
+    private createChangePath;
+    private isSuppressModelUpdateAfterUpdateTransaction;
+    refreshModel(params: RefreshModelParams): void;
+    isEmpty(): boolean;
+    isRowsToRender(): boolean;
+    getNodesInRangeForSelection(firstInRange: RowNode, lastInRange: RowNode): RowNode[];
+    getTopLevelNodes(): RowNode[] | null;
+    getRow(index: number): RowNode;
+    isRowPresent(rowNode: RowNode): boolean;
+    getRowIndexAtPixel(pixelToMatch: number): number;
+    private isRowInPixel;
+    forEachLeafNode(callback: (node: RowNode, index: number) => void): void;
+    forEachNode(callback: (node: RowNode, index: number) => void, includeFooterNodes?: boolean): void;
+    forEachNodeAfterFilter(callback: (node: RowNode, index: number) => void, includeFooterNodes?: boolean): void;
+    forEachNodeAfterFilterAndSort(callback: (node: RowNode, index: number) => void, includeFooterNodes?: boolean): void;
+    forEachPivotNode(callback: (node: RowNode, index: number) => void, includeFooterNodes?: boolean): void;
+    private recursivelyWalkNodesAndCallback;
+    doAggregate(changedPath?: ChangedPath): void;
+    private doFilterAggregates;
+    private doSort;
+    private doRowGrouping;
+    private doFilter;
+    private doPivot;
+    getRowNode(id: string): RowNode | undefined;
+    batchUpdateRowData(rowDataTransaction: RowDataTransaction, callback?: (res: RowNodeTransaction) => void): void;
+    flushAsyncTransactions(): void;
+    private executeBatchUpdateRowData;
+    /**
+     * Used to apply transaction changes.
+     * Called by gridApi & rowDragFeature
+     */
+    updateRowData(rowDataTran: RowDataTransaction): RowNodeTransaction | null;
+    /**
+     * Common to:
+     * - executeBatchUpdateRowData (batch transactions)
+     * - updateRowData (single transaction)
+     * - setImmutableRowData (generated transaction)
+     *
+     * @param rowNodeTrans - the transactions to apply
+     * @param orderChanged - whether the order of the rows has changed, either via generated transaction or user provided addIndex
+     */
+    private commitTransactions;
+    private doRowsToDisplay;
+    onRowHeightChanged(): void;
+    /** This method is debounced. It is used for row auto-height. If we don't debounce,
+     * then the Row Models will end up recalculating each row position
+     * for each row height change and result in the Row Renderer laying out rows.
+     * This is particularly bad if using print layout, and showing eg 1,000 rows,
+     * each row will change it's height, causing Row Model to update 1,000 times.
+     */
+    onRowHeightChangedDebounced(): void;
+    resetRowHeights(): void;
+    private resetRowHeightsForAllRowNodes;
+    private onGridStylesChanges;
+    private onGridReady;
+    isRowDataLoaded(): boolean;
+    destroy(): void;
+}

package/dist/types/src/clientSideRowModel/clientSideRowModelApi.d.ts

@@ -0,0 +1,16 @@
+import type { BeanCollection } from '../context/context';
+import type { ClientSideRowModelStep } from '../interfaces/iClientSideRowModel';
+import type { IRowNode } from '../interfaces/iRowNode';
+import type { RowDataTransaction } from '../interfaces/rowDataTransaction';
+import type { RowNodeTransaction } from '../interfaces/rowNodeTransaction';
+export declare function onGroupExpandedOrCollapsed(beans: BeanCollection): void;
+export declare function refreshClientSideRowModel(beans: BeanCollection, step?: ClientSideRowModelStep): void;
+export declare function isRowDataEmpty(beans: BeanCollection): boolean;
+export declare function forEachLeafNode<TData = any>(beans: BeanCollection, callback: (rowNode: IRowNode<TData>) => void): void;
+export declare function forEachNodeAfterFilter<TData = any>(beans: BeanCollection, callback: (rowNode: IRowNode<TData>, index: number) => void): void;
+export declare function forEachNodeAfterFilterAndSort<TData = any>(beans: BeanCollection, callback: (rowNode: IRowNode<TData>, index: number) => void): void;
+export declare function resetRowHeights(beans: BeanCollection): void;
+export declare function applyTransaction<TData = any>(beans: BeanCollection, rowDataTransaction: RowDataTransaction<TData>): RowNodeTransaction<TData> | null | undefined;
+export declare function applyTransactionAsync<TData = any>(beans: BeanCollection, rowDataTransaction: RowDataTransaction<TData>, callback?: (res: RowNodeTransaction<TData>) => void): void;
+export declare function flushAsyncTransactions(beans: BeanCollection): void;
+export declare function getBestCostNodeSelection<TData = any>(beans: BeanCollection): IRowNode<TData>[] | undefined;

package/dist/types/src/clientSideRowModel/clientSideRowModelModule.d.ts

@@ -0,0 +1,10 @@
+import type { _ClientSideRowModelGridApi } from '../api/gridApi';
+import type { _ModuleWithApi, _ModuleWithoutApi } from '../interfaces/iModule';
+/**
+ * @feature Client-Side Row Model
+ */
+export declare const ClientSideRowModelModule: _ModuleWithoutApi;
+/**
+ * @feature Client-Side Row Model
+ */
+export declare const ClientSideRowModelApiModule: _ModuleWithApi<_ClientSideRowModelGridApi<any>>;

package/dist/types/src/clientSideRowModel/filterStage.d.ts

@@ -0,0 +1,19 @@
+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 { RowNode } from '../entities/rowNode';
+import type { ClientSideRowModelStage } from '../interfaces/iClientSideRowModel';
+import type { IRowNodeStage, StageExecuteParams } from '../interfaces/iRowNodeStage';
+export declare function updateRowNodeAfterFilter(rowNode: RowNode): void;
+export declare class FilterStage extends BeanStub implements IRowNodeStage, NamedBean {
+    beanName: "filterStage";
+    refreshProps: Set<keyof GridOptions<any>>;
+    step: ClientSideRowModelStage;
+    private filterManager?;
+    wireBeans(beans: BeanCollection): void;
+    execute(params: StageExecuteParams): void;
+    private filter;
+    private filterNodes;
+    private doingTreeDataFiltering;
+}

package/dist/types/src/clientSideRowModel/sortStage.d.ts

@@ -0,0 +1,14 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { GridOptions } from '../entities/gridOptions';
+import type { RowNode } from '../entities/rowNode';
+import type { ClientSideRowModelStage } from '../interfaces/iClientSideRowModel';
+import type { IRowNodeStage, StageExecuteParams } from '../interfaces/iRowNodeStage';
+export declare function updateRowNodeAfterSort(rowNode: RowNode): void;
+export declare class SortStage extends BeanStub implements NamedBean, IRowNodeStage {
+    beanName: "sortStage";
+    refreshProps: Set<keyof GridOptions<any>>;
+    step: ClientSideRowModelStage;
+    execute(params: StageExecuteParams): void;
+    private sort;
+}

package/dist/types/src/columnAutosize/columnAutosizeApi.d.ts

@@ -0,0 +1,7 @@
+import type { BeanCollection } from '../context/context';
+import type { ColDef } from '../entities/colDef';
+import type { ISizeColumnsToFitParams } from '../interfaces/autoSize';
+import type { Column } from '../interfaces/iColumn';
+export declare function sizeColumnsToFit(beans: BeanCollection, paramsOrGridWidth?: ISizeColumnsToFitParams | number): void;
+export declare function autoSizeColumns(beans: BeanCollection, keys: (string | ColDef | Column)[], skipHeader?: boolean): void;
+export declare function autoSizeAllColumns(beans: BeanCollection, skipHeader?: boolean): void;

package/dist/types/src/columnAutosize/columnAutosizeModule.d.ts

@@ -0,0 +1,7 @@
+import type { _ColumnAutosizeApi } from '../api/gridApi';
+import type { _ModuleWithApi } from '../interfaces/iModule';
+/**
+ * @feature Columns -> Column Sizing
+ * @gridOption autoSizeStrategy
+ */
+export declare const ColumnAutoSizeModule: _ModuleWithApi<_ColumnAutosizeApi>;

package/dist/types/src/columnAutosize/columnAutosizeService.d.ts

@@ -0,0 +1,33 @@
+import type { ColKey, Maybe } 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 { ISizeColumnsToFitParams } from '../interfaces/autoSize';
+export declare class ColumnAutosizeService extends BeanStub implements NamedBean {
+    beanName: "colAutosize";
+    private timesDelayed;
+    shouldQueueResizeOperations: boolean;
+    private resizeOperationQueue;
+    postConstruct(): void;
+    autoSizeCols(params: {
+        colKeys: ColKey[];
+        skipHeader?: boolean;
+        skipHeaderGroups?: boolean;
+        stopAtGroup?: AgColumnGroup;
+        source?: ColumnEventType;
+    }): void;
+    autoSizeColumn(key: Maybe<ColKey>, source: ColumnEventType, skipHeader?: boolean): void;
+    private autoSizeColumnGroupsByColumns;
+    autoSizeAllColumns(source: ColumnEventType, skipHeader?: boolean): void;
+    addColumnAutosize(element: HTMLElement, column: AgColumn): () => void;
+    addColumnGroupResize(element: HTMLElement, columnGroup: AgColumnGroup, callback: () => void): () => void;
+    sizeColumnsToFitGridBody(params?: ISizeColumnsToFitParams, nextTimeout?: number): void;
+    sizeColumnsToFit(gridWidth: any, source?: ColumnEventType, silent?: boolean, params?: ISizeColumnsToFitParams): void;
+    applyAutosizeStrategy(): void;
+    private onFirstDataRendered;
+    processResizeOperations(): void;
+    pushResizeOperation(func: () => void): void;
+    destroy(): void;
+}

package/dist/types/src/columnMove/column-moving.css-GENERATED.d.ts

@@ -0,0 +1 @@
+export declare const columnMovingCSS = ":where(.ag-ltr) :where(.ag-column-moving){.ag-cell,.ag-header-cell{transition:left .2s}.ag-header-group-cell{transition:left .2s,width .2s}}:where(.ag-rtl) :where(.ag-column-moving){.ag-cell,.ag-header-cell{transition:right .2s}.ag-header-group-cell{transition:right .2s,width .2s}}";

package/dist/types/src/columnMove/columnAnimationService.d.ts

@@ -0,0 +1,21 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+export declare class ColumnAnimationService extends BeanStub implements NamedBean {
+    beanName: "colAnimation";
+    private gridBodyCtrl;
+    private executeNextFuncs;
+    private executeLaterFuncs;
+    private active;
+    private activeNext;
+    private suppressAnimation;
+    private animationThreadCount;
+    postConstruct(): void;
+    isActive(): boolean;
+    setSuppressAnimation(suppress: boolean): void;
+    start(): void;
+    finish(): void;
+    executeNextVMTurn(func: (...args: any[]) => any): void;
+    executeLaterVMTurn(func: (...args: any[]) => any): void;
+    private ensureAnimationCssClassPresent;
+    private flush;
+}

package/dist/types/src/columnMove/columnDrag/bodyDropPivotTarget.d.ts

@@ -0,0 +1,22 @@
+import { BeanStub } from '../../context/beanStub';
+import type { DragAndDropIcon, DraggingEvent } from '../../dragAndDrop/dragAndDropService';
+import type { ColumnPinnedType } from '../../interfaces/iColumn';
+import type { DropListener } from './bodyDropTarget';
+export declare class BodyDropPivotTarget extends BeanStub implements DropListener {
+    private readonly pinned;
+    private columnsToAggregate;
+    private columnsToGroup;
+    private columnsToPivot;
+    constructor(pinned: ColumnPinnedType);
+    /** Callback for when drag enters */
+    onDragEnter(draggingEvent: DraggingEvent): void;
+    getIconName(): DragAndDropIcon | null;
+    /** Callback for when drag leaves */
+    onDragLeave(draggingEvent: DraggingEvent): void;
+    private clearColumnsList;
+    /** Callback for when dragging */
+    onDragging(draggingEvent: DraggingEvent): void;
+    /** Callback for when drag stops */
+    onDragStop(draggingEvent: DraggingEvent): void;
+    onDragCancel(): void;
+}

package/dist/types/src/columnMove/columnDrag/bodyDropTarget.d.ts

@@ -0,0 +1,32 @@
+import { BeanStub } from '../../context/beanStub';
+import type { DragAndDropIcon, DraggingEvent, DropTarget } from '../../dragAndDrop/dragAndDropService';
+import { DragSourceType } from '../../dragAndDrop/dragAndDropService';
+import type { ColumnPinnedType } from '../../interfaces/iColumn';
+export interface DropListener {
+    getIconName(): DragAndDropIcon | null;
+    onDragEnter(params: DraggingEvent): void;
+    onDragLeave(params: DraggingEvent): void;
+    onDragging(params: DraggingEvent): void;
+    onDragStop(params: DraggingEvent): void;
+    onDragCancel(): void;
+}
+export declare class BodyDropTarget extends BeanStub implements DropTarget {
+    private readonly pinned;
+    private readonly eContainer;
+    private eSecondaryContainers;
+    private currentDropListener;
+    private moveColumnFeature;
+    private bodyDropPivotTarget;
+    constructor(pinned: ColumnPinnedType, eContainer: HTMLElement);
+    postConstruct(): void;
+    isInterestedIn(type: DragSourceType): boolean;
+    getSecondaryContainers(): HTMLElement[][];
+    getContainer(): HTMLElement;
+    getIconName(): DragAndDropIcon | null;
+    private isDropColumnInPivotMode;
+    onDragEnter(draggingEvent: DraggingEvent): void;
+    onDragLeave(params: DraggingEvent): void;
+    onDragging(params: DraggingEvent): void;
+    onDragStop(params: DraggingEvent): void;
+    onDragCancel(): void;
+}

package/dist/types/src/columnMove/columnDrag/moveColumnFeature.d.ts

@@ -0,0 +1,48 @@
+import { BeanStub } from '../../context/beanStub';
+import type { DragAndDropIcon, DraggingEvent } from '../../dragAndDrop/dragAndDropService';
+import type { AgColumn } from '../../entities/agColumn';
+import type { ColumnEventType } from '../../events';
+import type { ColumnPinnedType } from '../../interfaces/iColumn';
+import type { DropListener } from './bodyDropTarget';
+export declare class MoveColumnFeature extends BeanStub implements DropListener {
+    private readonly pinned;
+    private gridBodyCon;
+    private needToMoveLeft;
+    private needToMoveRight;
+    private movingIntervalId;
+    private intervalCount;
+    private isCenterContainer;
+    private lastDraggingEvent;
+    private lastHighlightedColumn;
+    private lastMovedInfo;
+    private failedMoveAttempts;
+    constructor(pinned: ColumnPinnedType);
+    postConstruct(): void;
+    getIconName(): DragAndDropIcon;
+    onDragEnter(draggingEvent: DraggingEvent): void;
+    onDragging(draggingEvent?: DraggingEvent | null, fromEnter?: boolean, fakeEvent?: boolean, finished?: boolean): void;
+    onDragLeave(): void;
+    onDragStop(): void;
+    onDragCancel(): void;
+    setColumnsVisible(columns: AgColumn[] | null | undefined, visible: boolean, source: ColumnEventType): void;
+    private finishColumnMoving;
+    private handleColumnDragWhileSuppressingMovement;
+    private handleColumnDragWhileAllowingMovement;
+    private getAllMovingColumns;
+    private getMoveColumnParams;
+    private highlightHoveredColumn;
+    private getNormalisedXPositionInfo;
+    private getColumnMoveAndTargetInfo;
+    private normaliseDirection;
+    private getNormalisedColumnLeft;
+    private isAttemptingToPin;
+    private moveColumnsAfterHighlight;
+    private clearHighlighted;
+    private checkCenterForScrolling;
+    private ensureIntervalStarted;
+    private ensureIntervalCleared;
+    private moveInterval;
+    private getPinDirection;
+    private attemptToPinColumns;
+    destroy(): void;
+}

package/dist/types/src/columnMove/columnMoveApi.d.ts

@@ -0,0 +1,5 @@
+import type { BeanCollection } from '../context/context';
+import type { ColDef } from '../entities/colDef';
+import type { Column } from '../interfaces/iColumn';
+export declare function moveColumnByIndex(beans: BeanCollection, fromIndex: number, toIndex: number): void;
+export declare function moveColumns(beans: BeanCollection, columnsToMoveKeys: (string | ColDef | Column)[], toIndex: number): void;

package/dist/types/src/columnMove/columnMoveModule.d.ts

@@ -0,0 +1,6 @@
+import type { _ColumnMoveApi } from '../api/gridApi';
+import type { _ModuleWithApi } from '../interfaces/iModule';
+/**
+ * @feature Columns -> Column Moving
+ */
+export declare const ColumnMoveModule: _ModuleWithApi<_ColumnMoveApi>;

package/dist/types/src/columnMove/columnMoveService.d.ts

@@ -0,0 +1,21 @@
+import type { ColKey } from '../columns/columnModel';
+import type { HorizontalDirection } from '../constants/direction';
+import type { NamedBean } from '../context/bean';
+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 { ColumnEventType } from '../events';
+import type { ColumnPinnedType } from '../interfaces/iColumn';
+import { BodyDropTarget } from './columnDrag/bodyDropTarget';
+export declare class ColumnMoveService extends BeanStub implements NamedBean {
+    beanName: "colMoves";
+    moveColumnByIndex(fromIndex: number, toIndex: number, source: ColumnEventType): void;
+    moveColumns(columnsToMoveKeys: ColKey[], toIndex: number, source: ColumnEventType, finished?: boolean): void;
+    private doesMovePassRules;
+    doesOrderPassRules(gridOrder: AgColumn[]): boolean;
+    getProposedColumnOrder(columnsToMove: AgColumn[], toIndex: number): AgColumn[];
+    createBodyDropTarget(pinned: ColumnPinnedType, dropContainer: HTMLElement): BodyDropTarget;
+    moveHeader(hDirection: HorizontalDirection, eGui: HTMLElement, column: AgColumn | AgColumnGroup, pinned: ColumnPinnedType, bean: BeanStub): void;
+    setDragSourceForHeader(eSource: HTMLElement, column: AgColumn | AgColumnGroup, displayName: string | null): DragSource;
+}

package/dist/types/src/columnMove/columnMoveUtils.d.ts

@@ -0,0 +1,5 @@
+import type { AgColumn } from '../entities/agColumn';
+import type { AgProvidedColumnGroup } from '../entities/agProvidedColumnGroup';
+import type { GridOptionsService } from '../gridOptionsService';
+export declare function placeLockedColumns(cols: AgColumn[], gos: GridOptionsService): AgColumn[];
+export declare function doesMovePassMarryChildren(allColumnsCopy: AgColumn[], gridBalancedTree: (AgColumn | AgProvidedColumnGroup)[]): boolean;

package/dist/types/src/columnMove/internalColumnMoveUtils.d.ts

@@ -0,0 +1,40 @@
+import type { ColumnModel } from '../columns/columnModel';
+import type { VisibleColsService } from '../columns/visibleColsService';
+import type { CtrlsService } from '../ctrlsService';
+import type { AgColumn } from '../entities/agColumn';
+import type { GridOptionsService } from '../gridOptionsService';
+import type { ColumnPinnedType } from '../interfaces/iColumn';
+import type { ColumnMoveService } from './columnMoveService';
+export interface ColumnMoveParams {
+    allMovingColumns: AgColumn[];
+    isFromHeader: boolean;
+    fromLeft: boolean;
+    xPosition: number;
+    fromEnter: boolean;
+    fakeEvent: boolean;
+    pinned: ColumnPinnedType;
+    gos: GridOptionsService;
+    colModel: ColumnModel;
+    colMoves: ColumnMoveService;
+    visibleCols: VisibleColsService;
+}
+export declare function getBestColumnMoveIndexFromXPosition(params: ColumnMoveParams): {
+    columns: AgColumn[];
+    toIndex: number;
+} | undefined;
+export declare function attemptMoveColumns(params: ColumnMoveParams & {
+    finished: boolean;
+}): {
+    columns: AgColumn[];
+    toIndex: number;
+} | null | undefined;
+export declare function normaliseX(params: {
+    x: number;
+    pinned?: ColumnPinnedType;
+    fromKeyboard?: boolean;
+    useHeaderRow?: boolean;
+    skipScrollPadding?: boolean;
+    gos: GridOptionsService;
+    ctrlsSvc: CtrlsService;
+}): number;
+export declare function setColumnsMoving(columns: AgColumn[], isMoving: boolean): void;

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

@@ -0,0 +1,8 @@
+import type { BeanCollection } from '../context/context';
+import type { ColDef } from '../entities/colDef';
+import type { ColumnEventType } from '../events';
+import type { Column } from '../interfaces/iColumn';
+export declare function setColumnWidths(beans: BeanCollection, columnWidths: {
+    key: string | ColDef | Column;
+    newWidth: number;
+}[], finished?: boolean, source?: ColumnEventType): void;

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

@@ -0,0 +1,6 @@
+import type { _ColumnResizeApi } from '../api/gridApi';
+import type { _ModuleWithApi } from '../interfaces/iModule';
+/**
+ * @feature Columns -> Column Sizing
+ */
+export declare const ColumnResizeModule: _ModuleWithApi<_ColumnResizeApi>;