ag-grid-community 32.3.2 → 33.0.0

package/dist/types/src/headerRendering/cells/floatingFilter/headerFilterCellCtrl.d.ts

@@ -0,0 +1,41 @@
+import type { BeanStub } from '../../../context/beanStub';
+import type { AgColumn } from '../../../entities/agColumn';
+import { AbstractHeaderCellCtrl } from '../abstractCell/abstractHeaderCellCtrl';
+import type { IHeaderFilterCellComp } from './iHeaderFilterCellComp';
+export declare class HeaderFilterCellCtrl extends AbstractHeaderCellCtrl<IHeaderFilterCellComp, AgColumn> {
+    private eButtonShowMainFilter;
+    private eFloatingFilterBody;
+    private suppressFilterButton;
+    private highlightFilterButtonWhenActive;
+    private active;
+    private iconCreated;
+    private userCompDetails?;
+    private destroySyncListener;
+    private destroyFilterChangedListener;
+    setComp(comp: IHeaderFilterCellComp, eGui: HTMLElement, eButtonShowMainFilter: HTMLElement, eFloatingFilterBody: HTMLElement, compBeanInput: BeanStub | undefined): void;
+    protected resizeHeader(): void;
+    protected moveHeader(): void;
+    private setupActive;
+    private setupUi;
+    private setupFocus;
+    private setupAria;
+    private onTabKeyDown;
+    private findNextColumnWithFloatingFilter;
+    protected handleKeyDown(e: KeyboardEvent): void;
+    private onFocusIn;
+    private setupHover;
+    private setupLeft;
+    private setupFilterButton;
+    private setupUserComp;
+    private setCompDetails;
+    private showParentFilter;
+    private setupSyncWithFilter;
+    private setupWidth;
+    private setupFilterChangedListener;
+    private updateFilterButton;
+    private onColDefChanged;
+    private updateCompDetails;
+    private updateFloatingFilterParams;
+    protected addResizeAndMoveKeyboardListeners(): void;
+    destroy(): void;
+}

package/dist/types/src/headerRendering/cells/floatingFilter/iHeaderFilterCellComp.d.ts

@@ -0,0 +1,12 @@
+import type { IFloatingFilter } from '../../../filter/floating/floatingFilter';
+import type { UserCompDetails } from '../../../interfaces/iUserCompDetails';
+import type { AgPromise } from '../../../utils/promise';
+import type { IAbstractHeaderCellComp } from '../abstractCell/abstractHeaderCellCtrl';
+export interface IHeaderFilterCellComp extends IAbstractHeaderCellComp {
+    addOrRemoveBodyCssClass(cssClassName: string, on: boolean): void;
+    setButtonWrapperDisplayed(displayed: boolean): void;
+    setCompDetails(compDetails?: UserCompDetails | null): void;
+    getFloatingFilterComp(): AgPromise<IFloatingFilter> | null;
+    setWidth(width: string): void;
+    setMenuIcon(icon: HTMLElement): void;
+}

package/dist/types/src/headerRendering/cells/headerModule.d.ts

@@ -0,0 +1,11 @@
+import type { _ModuleWithoutApi } from '../../interfaces/iModule';
+/**
+ * @feature Columns -> Column Header
+ * @colDef headerComponent
+ */
+export declare const ColumnHeaderCompModule: _ModuleWithoutApi;
+/**
+ * @feature Columns -> Column Groups
+ * @colGroupDef headerGroupComponent
+ */
+export declare const ColumnGroupHeaderCompModule: _ModuleWithoutApi;

package/dist/types/src/headerRendering/gridHeaderCtrl.d.ts

@@ -0,0 +1,19 @@
+import { BeanStub } from '../context/beanStub';
+export interface IGridHeaderComp {
+    addOrRemoveCssClass(cssClassName: string, on: boolean): void;
+    setHeightAndMinHeight(height: string): void;
+}
+export declare class GridHeaderCtrl extends BeanStub {
+    private comp;
+    eGui: HTMLElement;
+    headerHeight: number;
+    setComp(comp: IGridHeaderComp, eGui: HTMLElement, eFocusableElement: HTMLElement): void;
+    private setupHeaderHeight;
+    private setHeaderHeight;
+    private onPivotModeChanged;
+    private onDisplayedColumnsChanged;
+    protected onTabKeyDown(e: KeyboardEvent): void;
+    protected handleKeyDown(e: KeyboardEvent): void;
+    protected onFocusOut(e: FocusEvent): void;
+    private onHeaderContextMenu;
+}

package/dist/types/src/headerRendering/headerUtils.d.ts

@@ -0,0 +1,8 @@
+import type { ColumnModel } from '../columns/columnModel';
+import type { BeanCollection } from '../context/context';
+export declare function getHeaderRowCount(colModel: ColumnModel): number;
+export declare function getFocusHeaderRowCount(beans: BeanCollection): number;
+export declare function getGroupRowsHeight(beans: BeanCollection): number[];
+export declare function getColumnHeaderRowHeight(beans: BeanCollection): number;
+export declare function getHeaderHeight(beans: BeanCollection): number;
+export declare function getFloatingFiltersHeight(beans: BeanCollection): number;

package/dist/types/src/headerRendering/row/headerRowComp.d.ts

@@ -0,0 +1,12 @@
+import { Component } from '../../widgets/component';
+import type { HeaderRowCtrl } from './headerRowCtrl';
+export type HeaderRowType = 'group' | 'column' | 'filter';
+export declare class HeaderRowComp extends Component {
+    private ctrl;
+    private headerComps;
+    constructor(ctrl: HeaderRowCtrl);
+    postConstruct(): void;
+    destroy(): void;
+    private setHeaderCtrls;
+    private createHeaderComp;
+}

package/dist/types/src/headerRendering/row/headerRowCtrl.d.ts

@@ -0,0 +1,59 @@
+import { BeanStub } from '../../context/beanStub';
+import type { AgColumn } from '../../entities/agColumn';
+import type { AgColumnGroup } from '../../entities/agColumnGroup';
+import type { BrandedType } from '../../interfaces/brandedType';
+import type { ColumnPinnedType } from '../../interfaces/iColumn';
+import type { AbstractHeaderCellCtrl } from '../cells/abstractCell/abstractHeaderCellCtrl';
+import type { HeaderRowType } from './headerRowComp';
+export interface IHeaderRowComp {
+    setTop(top: string): void;
+    setHeight(height: string): void;
+    setHeaderCtrls(ctrls: AbstractHeaderCellCtrl[], forceOrder: boolean, afterScroll: boolean): void;
+    setWidth(width: string): void;
+}
+export type HeaderRowCtrlInstanceId = BrandedType<number, 'HeaderRowCtrlInstanceId'>;
+export declare class HeaderRowCtrl extends BeanStub {
+    readonly rowIndex: number;
+    readonly pinned: ColumnPinnedType;
+    readonly type: HeaderRowType;
+    readonly instanceId: HeaderRowCtrlInstanceId;
+    private comp;
+    headerRowClass: string;
+    private headerCellCtrls;
+    private isPrintLayout;
+    private isEnsureDomOrder;
+    constructor(rowIndex: number, pinned: ColumnPinnedType, type: HeaderRowType);
+    postConstruct(): void;
+    /** Checks that every header cell that is currently visible has been rendered.
+     * Can only be false under some circumstances when using React
+     */
+    areCellsRendered(): boolean;
+    /**
+     *
+     * @param comp Proxy to the actual component
+     * @param initCompState Should the component be initialised with the current state of the controller. Default: true
+     */
+    setComp(comp: IHeaderRowComp, compBean: BeanStub | undefined, initCompState?: boolean): void;
+    getAriaRowIndex(): number;
+    private addEventListeners;
+    getHeaderCellCtrl(column: AgColumn | AgColumnGroup): AbstractHeaderCellCtrl | undefined;
+    private onDisplayedColumnsChanged;
+    private setWidth;
+    private getWidthForRow;
+    private onRowHeightChanged;
+    getTopAndHeight(): {
+        topOffset: number;
+        rowHeight: number;
+    };
+    private onVirtualColumnsChanged;
+    getHeaderCtrls(): AbstractHeaderCellCtrl<any, any, any>[];
+    private getHeaderCellCtrls;
+    private recycleAndCreateHeaderCtrls;
+    private getColumnsInViewport;
+    private getColumnsInViewportPrintLayout;
+    private getActualDepth;
+    private getColumnsInViewportNormalLayout;
+    findHeaderCellCtrl(column: AgColumn | AgColumnGroup | ((cellCtrl: AbstractHeaderCellCtrl) => boolean)): AbstractHeaderCellCtrl | undefined;
+    focusHeader(column: AgColumn | AgColumnGroup, event?: KeyboardEvent): boolean;
+    destroy(): void;
+}

package/dist/types/src/headerRendering/rowContainer/headerRowContainerCtrl.d.ts

@@ -0,0 +1,44 @@
+import { BeanStub } from '../../context/beanStub';
+import type { AgColumn } from '../../entities/agColumn';
+import type { AgColumnGroup } from '../../entities/agColumnGroup';
+import type { ScrollPartner } from '../../gridBodyComp/gridBodyScrollFeature';
+import type { ColumnPinnedType } from '../../interfaces/iColumn';
+import type { AbstractHeaderCellCtrl } from '../cells/abstractCell/abstractHeaderCellCtrl';
+import type { HeaderRowType } from '../row/headerRowComp';
+import { HeaderRowCtrl } from '../row/headerRowCtrl';
+export interface IHeaderRowContainerComp {
+    setCenterWidth(width: string): void;
+    setViewportScrollLeft(left: number): void;
+    setPinnedContainerWidth(width: string): void;
+    setDisplayed(displayed: boolean): void;
+    setCtrls(ctrls: HeaderRowCtrl[]): void;
+}
+export declare class HeaderRowContainerCtrl extends BeanStub implements ScrollPartner {
+    readonly pinned: ColumnPinnedType;
+    comp: IHeaderRowContainerComp;
+    hidden: boolean;
+    private includeFloatingFilter;
+    private filtersRowCtrl;
+    private columnsRowCtrl;
+    private groupsRowCtrls;
+    eViewport: HTMLElement;
+    constructor(pinned: ColumnPinnedType);
+    setComp(comp: IHeaderRowContainerComp, eGui: HTMLElement): void;
+    getAllCtrls(): HeaderRowCtrl[];
+    refresh(keepColumns?: boolean): void;
+    getHeaderCtrlForColumn(column: AgColumn | AgColumnGroup): AbstractHeaderCellCtrl | undefined;
+    getHtmlElementForColumnHeader(column: AgColumn | AgColumnGroup): HTMLElement | null;
+    getRowType(rowIndex: number): HeaderRowType | undefined;
+    focusHeader(rowIndex: number, column: AgColumn | AgColumnGroup, event?: KeyboardEvent): boolean;
+    getGroupRowCount(): number;
+    getGroupRowCtrlAtIndex(index: number): HeaderRowCtrl;
+    getRowCount(): number;
+    setHorizontalScroll(offset: number): void;
+    onScrollCallback(fn: () => void): void;
+    destroy(): void;
+    private setupDragAndDrop;
+    private restoreFocusOnHeader;
+    private onGridColumnsChanged;
+    private onDisplayedColumnsChanged;
+    private setupCenterWidth;
+}

package/dist/types/src/infiniteRowModel/infiniteBlock.d.ts

@@ -0,0 +1,38 @@
+import { BeanStub } from '../context/beanStub';
+import { RowNode } from '../entities/rowNode';
+import type { InfiniteCache, InfiniteCacheParams } from './infiniteCache';
+type RowNodeBlockState = 'needsLoading' | 'loading' | 'loaded' | 'failed';
+export type RowNodeBlockEvent = 'loadComplete';
+export declare class InfiniteBlock extends BeanStub<RowNodeBlockEvent> {
+    readonly id: number;
+    private readonly parentCache;
+    private readonly params;
+    state: RowNodeBlockState;
+    version: number;
+    readonly startRow: number;
+    readonly endRow: number;
+    lastAccessed: number;
+    rowNodes: RowNode[];
+    constructor(id: number, parentCache: InfiniteCache, params: InfiniteCacheParams);
+    load(): void;
+    setStateWaitingToLoad(): void;
+    private pageLoadFailed;
+    private pageLoaded;
+    private isRequestMostRecentAndLive;
+    private successCommon;
+    postConstruct(): void;
+    getBlockStateJson(): {
+        id: string;
+        state: any;
+    };
+    private setDataAndId;
+    private loadFromDatasource;
+    private createLoadParams;
+    forEachNode(callback: (rowNode: RowNode, index: number) => void, sequence: {
+        value: number;
+    }, rowCount: number): void;
+    getRow(rowIndex: number, dontTouchLastAccessed?: boolean): RowNode;
+    private processServerResult;
+    destroy(): void;
+}
+export {};

package/dist/types/src/infiniteRowModel/infiniteCache.d.ts

@@ -0,0 +1,49 @@
+import { BeanStub } from '../context/beanStub';
+import type { RowNode } from '../entities/rowNode';
+import type { IDatasource } from '../interfaces/iDatasource';
+import type { SortModelItem } from '../interfaces/iSortModelItem';
+import { InfiniteBlock } from './infiniteBlock';
+import type { RowNodeBlockLoader } from './rowNodeBlockLoader';
+export interface InfiniteCacheParams {
+    datasource: IDatasource;
+    initialRowCount: number;
+    blockSize?: number;
+    overflowSize: number;
+    sortModel: SortModelItem[];
+    filterModel: any;
+    maxBlocksInCache?: number;
+    rowHeight: number;
+    lastAccessedSequence: {
+        value: number;
+    };
+    rowNodeBlockLoader?: RowNodeBlockLoader;
+    dynamicRowHeight: boolean;
+}
+export declare class InfiniteCache extends BeanStub {
+    private readonly params;
+    private rowCount;
+    private lastRowIndexKnown;
+    private blocks;
+    private blockCount;
+    constructor(params: InfiniteCacheParams);
+    getRow(rowIndex: number, dontCreatePage?: boolean): RowNode | undefined;
+    private createBlock;
+    refreshCache(): void;
+    destroy(): void;
+    getRowCount(): number;
+    isLastRowIndexKnown(): boolean;
+    pageLoaded(block: InfiniteBlock, lastRow?: number): void;
+    private purgeBlocksIfNeeded;
+    private isBlockFocused;
+    private isBlockCurrentlyDisplayed;
+    private removeBlockFromCache;
+    private checkRowCount;
+    setRowCount(rowCount: number, lastRowIndexKnown?: boolean): void;
+    forEachNodeDeep(callback: (rowNode: RowNode, index: number) => void): void;
+    getBlocksInOrder(): InfiniteBlock[];
+    private destroyBlock;
+    private onCacheUpdated;
+    private destroyAllBlocksPastVirtualRowCount;
+    purgeCache(): void;
+    getRowNodesInRange(firstInRange: RowNode, lastInRange: RowNode): RowNode[];
+}

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

@@ -0,0 +1,42 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { RowNode } from '../entities/rowNode';
+import type { IDatasource } from '../interfaces/iDatasource';
+import type { IRowModel, RowBounds, RowModelType } from '../interfaces/iRowModel';
+export declare class InfiniteRowModel extends BeanStub implements NamedBean, IRowModel {
+    beanName: "rowModel";
+    private infiniteCache;
+    private datasource;
+    private rowHeight;
+    private cacheParams;
+    getRowBounds(index: number): RowBounds;
+    ensureRowHeightsValid(): boolean;
+    postConstruct(): void;
+    start(): void;
+    destroy(): void;
+    private destroyDatasource;
+    private addEventListeners;
+    private onColumnEverything;
+    getType(): RowModelType;
+    setDatasource(datasource: IDatasource | undefined): void;
+    isEmpty(): boolean;
+    isRowsToRender(): boolean;
+    getNodesInRangeForSelection(firstInRange: RowNode, lastInRange: RowNode): RowNode[];
+    private reset;
+    private dispatchModelUpdatedEvent;
+    private resetCache;
+    private updateRowHeights;
+    private destroyCache;
+    getRow(rowIndex: number): RowNode | undefined;
+    getRowNode(id: string): RowNode | undefined;
+    forEachNode(callback: (rowNode: RowNode, index: number) => void): void;
+    getTopLevelRowCount(): number;
+    getTopLevelRowDisplayedIndex(topLevelIndex: number): number;
+    getRowIndexAtPixel(pixel: number): number;
+    getRowCount(): number;
+    isRowPresent(rowNode: RowNode): boolean;
+    refreshCache(): void;
+    purgeCache(): void;
+    isLastRowIndexKnown(): boolean;
+    setRowCount(rowCount: number, lastRowIndexKnown?: boolean): void;
+}

package/dist/types/src/infiniteRowModel/infiniteRowModelApi.d.ts

@@ -0,0 +1,4 @@
+import type { BeanCollection } from '../context/context';
+export declare function refreshInfiniteCache(beans: BeanCollection): void;
+export declare function purgeInfiniteCache(beans: BeanCollection): void;
+export declare function getInfiniteRowCount(beans: BeanCollection): number | undefined;

package/dist/types/src/infiniteRowModel/infiniteRowModelModule.d.ts

@@ -0,0 +1,6 @@
+import type { _InfiniteRowModelGridApi } from '../api/gridApi';
+import type { _ModuleWithApi } from '../interfaces/iModule';
+/**
+ * @feature Infinite Row Model
+ */
+export declare const InfiniteRowModelModule: _ModuleWithApi<_InfiniteRowModelGridApi>;

package/dist/types/src/infiniteRowModel/rowNodeBlockLoader.d.ts

@@ -0,0 +1,23 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { InfiniteBlock } from './infiniteBlock';
+export type RowNodeBlockLoaderEvent = 'blockLoaded';
+export declare class RowNodeBlockLoader extends BeanStub<RowNodeBlockLoaderEvent> implements NamedBean {
+    beanName: "rowNodeBlockLoader";
+    private maxConcurrentRequests;
+    private checkBlockToLoadDebounce;
+    private activeBlockLoadsCount;
+    private blocks;
+    private active;
+    postConstruct(): void;
+    addBlock(block: InfiniteBlock): void;
+    removeBlock(block: InfiniteBlock): void;
+    destroy(): void;
+    private loadComplete;
+    checkBlockToLoad(): void;
+    private performCheckBlocksToLoad;
+    getBlockState(): {
+        [key: string]: any;
+    };
+    private printCacheStatus;
+}

package/dist/types/src/interfaces/IRangeService.d.ts

@@ -0,0 +1,81 @@
+import type { BeanStub } from '../context/beanStub';
+import type { BeanCollection } from '../context/context';
+import type { Column } from '../interfaces/iColumn';
+import type { RowPinnedType } from '../interfaces/iRowNode';
+import type { CellCtrl } from '../rendering/cell/cellCtrl';
+import type { CellPosition } from './iCellPosition';
+import type { ICellRangeFeature } from './iCellRangeFeature';
+import type { RowPosition } from './iRowPosition';
+export interface IRangeService {
+    isEmpty(): boolean;
+    removeAllCellRanges(silent?: boolean): void;
+    getCellRangeCount(cell: CellPosition): number;
+    isCellInAnyRange(cell: CellPosition): boolean;
+    isCellInSpecificRange(cell: CellPosition, range: CellRange): boolean;
+    isBottomRightCell(cellRange: CellRange, cell: CellPosition): boolean;
+    isContiguousRange(cellRange: CellRange): boolean;
+    isMoreThanOneCell(): boolean;
+    areAllRangesAbleToMerge(): boolean;
+    onDragStart(mouseEvent: MouseEvent): void;
+    onDragStop(): void;
+    onDragging(mouseEvent: MouseEvent): void;
+    getCellRanges(): CellRange[];
+    setRangeToCell(cell: CellPosition, appendRange?: boolean): void;
+    intersectLastRange(fromMouseClick?: boolean): void;
+    setCellRange(params: CellRangeParams): void;
+    addCellRange(params: CellRangeParams): void;
+    extendLatestRangeInDirection(event: KeyboardEvent): CellPosition | undefined;
+    extendLatestRangeToCell(cell: CellPosition): void;
+    updateRangeEnd(cellRange: CellRange, cellPosition: CellPosition, silent?: boolean): void;
+    getRangeStartRow(cellRange: PartialCellRange): RowPosition;
+    getRangeEndRow(cellRange: PartialCellRange): RowPosition;
+    createCellRangeFromCellRangeParams(params: CellRangeParams): CellRange | undefined;
+    createPartialCellRangeFromRangeParams(params: CellRangeParams, allowEmptyColumns: boolean): PartialCellRange | undefined;
+    setCellRanges(cellRanges: CellRange[]): void;
+    clearCellRangeCellValues(params: ClearCellRangeParams): void;
+    createDragListenerFeature(eContainer: HTMLElement): BeanStub;
+    createCellRangeFeature(beans: BeanCollection, ctrl: CellCtrl): ICellRangeFeature;
+}
+export declare enum CellRangeType {
+    VALUE = 0,
+    DIMENSION = 1
+}
+/** Describes a single range of cells */
+export interface CellRange {
+    id?: string;
+    type?: CellRangeType;
+    /** The start row of the range */
+    startRow?: RowPosition;
+    /** The end row of the range */
+    endRow?: RowPosition;
+    /** The columns in the range */
+    columns: Column[];
+    /** The start column for the range */
+    startColumn: Column;
+}
+export type PartialCellRange = Omit<CellRange, 'startColumn'> & Partial<Pick<CellRange, 'startColumn'>>;
+export interface CellRangeParams {
+    /** Start row index */
+    rowStartIndex: number | null;
+    /** Pinned state of start row. Either 'top', 'bottom' or null */
+    rowStartPinned?: RowPinnedType;
+    /** End row index */
+    rowEndIndex: number | null;
+    /** Pinned state of end row. Either 'top', 'bottom' or null */
+    rowEndPinned?: RowPinnedType;
+    /** Starting column for range */
+    columnStart?: string | Column;
+    /** End column for range */
+    columnEnd?: string | Column;
+    /** Specify Columns to include instead of using `columnStart` and `columnEnd` */
+    columns?: (string | Column)[];
+}
+export interface ClearCellRangeParams {
+    cellRanges?: CellRange[];
+    /** Source passed to `cellValueChanged` event */
+    cellEventSource?: string;
+    /** `true` to dispatch `cellSelectionDeleteStart` and `cellSelectionDeleteEnd` events */
+    dispatchWrapperEvents?: boolean;
+    /** Source passed to `cellSelectionDeleteStart` and `cellSelectionDeleteEnd` events */
+    wrapperEventSource?: 'deleteKey';
+}

package/dist/types/src/interfaces/IServerSideStore.d.ts

@@ -0,0 +1,35 @@
+import type { Bean } from '../context/bean';
+export interface IServerSideStore extends Bean {
+    getStoreBounds(): {
+        topPx: number;
+        heightPx: number;
+    };
+}
+export interface StoreRefreshAfterParams {
+    valueColChanged: boolean;
+    secondaryColChanged: boolean;
+    changedColumns: string[];
+}
+export interface ServerSideGroupLevelState {
+    /** The route that identifies this level. */
+    route: string[];
+    /** How many rows the level has. This includes 'loading rows'. */
+    rowCount: number;
+    /**
+     * Infinite Scroll only.
+     * Whether the last row index is know.
+     * */
+    lastRowIndexKnown?: boolean;
+    /** Any extra info provided to the level, when data was loaded. */
+    info?: any;
+    /**
+     *Infinite Scroll only.
+     * Max blocks allowed in the infinite cache.
+     */
+    maxBlocksInCache?: number;
+    /**
+     * Infinite Scroll only.
+     * The size (number of rows) of each infinite cache block.
+     */
+    cacheBlockSize?: number;
+}

package/dist/types/src/interfaces/autoSize.d.ts

@@ -0,0 +1,51 @@
+import type { Column } from './iColumn';
+export interface IColumnLimit {
+    /** Selector for the column to which these dimension limits will apply */
+    key: Column | string;
+    /** Defines a minimum width for this column (does not override the column minimum width) */
+    minWidth?: number;
+    /** Defines a maximum width for this column (does not override the column maximum width) */
+    maxWidth?: number;
+}
+export interface ISizeColumnsToFitParams {
+    /** Defines a default minimum width for every column (does not override the column minimum width) */
+    defaultMinWidth?: number;
+    /** Defines a default maximum width for every column (does not override the column maximum width) */
+    defaultMaxWidth?: number;
+    /** Provides a minimum and/or maximum width to specific columns */
+    columnLimits?: IColumnLimit[];
+}
+/** Limit a column width when auto-sizing to fit grid width. */
+export interface SizeColumnsToFitGridColumnLimits {
+    colId: string;
+    /** Minimum width for this column (does not override the column minimum width) */
+    minWidth?: number;
+    /** Maximum width for this column (does not override the column maximum width) */
+    maxWidth?: number;
+}
+/** Auto-size columns to fit the grid width. */
+export interface SizeColumnsToFitGridStrategy {
+    type: 'fitGridWidth';
+    /** Default minimum width for every column (does not override the column minimum width). */
+    defaultMinWidth?: number;
+    /** Default maximum width for every column (does not override the column maximum width). */
+    defaultMaxWidth?: number;
+    /** Provide to limit specific column widths when sizing. */
+    columnLimits?: SizeColumnsToFitGridColumnLimits[];
+}
+/** Auto-size columns to fit a provided width. */
+export interface SizeColumnsToFitProvidedWidthStrategy {
+    type: 'fitProvidedWidth';
+    width: number;
+}
+/**
+ * Auto-size columns to fit their cell contents.
+ * Only works for Client-Side Row Model and Server-Side Row Model.
+ */
+export interface SizeColumnsToContentStrategy {
+    type: 'fitCellContents';
+    /** If true, the header won't be included when calculating the column widths. */
+    skipHeader?: boolean;
+    /** If not provided will auto-size all columns. Otherwise will size the specified columns. */
+    colIds?: string[];
+}

package/dist/types/src/interfaces/dateComponent.d.ts

@@ -0,0 +1,42 @@
+import type { DateFilterParams } from '../filter/provided/date/iDateFilter';
+import type { IAfterGuiAttachedParams } from '../interfaces/iAfterGuiAttachedParams';
+import type { AgGridCommon } from '../interfaces/iCommon';
+import type { IComponent } from '../interfaces/iComponent';
+export interface BaseDate {
+    /** Optional: Sets the disabled state of this component */
+    setDisabled?(disabled: boolean): void;
+    /** Optional: Sets the current input placeholder */
+    setInputPlaceholder?(placeholder: string): void;
+    /** Optional: Sets the current input aria label */
+    setInputAriaLabel?(placeholder: string): void;
+    /**
+     * Optional: A hook to perform any necessary operation just after
+     * the GUI for this component has been rendered on the screen.
+     * If a parent popup is closed and reopened (e.g. for filters),
+     * this method is called each time the component is shown.
+     * This is useful for any logic that requires attachment before executing,
+     * such as putting focus on a particular DOM element.
+     */
+    afterGuiAttached?(params?: IAfterGuiAttachedParams): void;
+}
+export interface IDate extends BaseDate {
+    /** Returns the current date represented by this component */
+    getDate(): Date | null;
+    /** Sets the date represented by this component */
+    setDate(date: Date | null): void;
+    /**
+     * When used in a floating filter, a hook to perform any necessary operations
+     * when the column definition is updated.
+     */
+    refresh?(params: IDateParams): void;
+}
+export interface BaseDateParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    filterParams: DateFilterParams;
+    location?: 'filter' | 'floatingFilter';
+}
+export interface IDateParams<TData = any, TContext = any> extends BaseDateParams<TData, TContext> {
+    /** Method for component to tell AG Grid that the date has changed. */
+    onDateChanged: () => void;
+}
+export interface IDateComp extends IComponent<IDateParams>, IDate {
+}