ag-grid-community 32.3.2 → 33.0.0

package/dist/types/src/gridBodyComp/fakeVScrollComp.d.ts

@@ -0,0 +1,11 @@
+import type { ComponentSelector } from '../widgets/component';
+import { AbstractFakeScrollComp } from './abstractFakeScrollComp';
+export declare class FakeVScrollComp extends AbstractFakeScrollComp {
+    constructor();
+    postConstruct(): void;
+    protected setScrollVisible(): void;
+    private onRowContainerHeightChanged;
+    getScrollPosition(): number;
+    setScrollPosition(value: number, force?: boolean): void;
+}
+export declare const FakeVScrollSelector: ComponentSelector;

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

@@ -0,0 +1,15 @@
+import type { ComponentSelector } from '../widgets/component';
+import { Component } from '../widgets/component';
+export declare class GridBodyComp extends Component {
+    private readonly eGridRoot;
+    private readonly eBodyViewport;
+    private readonly eStickyTop;
+    private readonly eStickyBottom;
+    private readonly eTop;
+    private readonly eBottom;
+    private readonly eBody;
+    private ctrl;
+    postConstruct(): void;
+    private setRowAnimationCssOnBodyViewport;
+}
+export declare const GridBodySelector: ComponentSelector;

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

@@ -0,0 +1,81 @@
+import { BeanStub } from '../context/beanStub';
+import type { BeanCollection } from '../context/context';
+import type { LayoutView } from '../styling/layoutFeature';
+import { GridBodyScrollFeature } from './gridBodyScrollFeature';
+export type RowAnimationCssClasses = 'ag-row-animation' | 'ag-row-no-animation';
+export declare const CSS_CLASS_FORCE_VERTICAL_SCROLL = "ag-force-vertical-scroll";
+export interface IGridBodyComp extends LayoutView {
+    setColumnMovingCss(cssClass: string, on: boolean): void;
+    setCellSelectableCss(cssClass: string | null, on: boolean): void;
+    setTopHeight(height: number): void;
+    setTopDisplay(display: string): void;
+    setBottomHeight(height: number): void;
+    setBottomDisplay(display: string): void;
+    setStickyTopHeight(height: string): void;
+    setStickyTopTop(offsetTop: string): void;
+    setStickyTopWidth(width: string): void;
+    setStickyBottomHeight(height: string): void;
+    setStickyBottomBottom(offsetBottom: string): void;
+    setStickyBottomWidth(width: string): void;
+    setColumnCount(count: number): void;
+    setRowCount(count: number): void;
+    setRowAnimationCssOnBodyViewport(cssClass: RowAnimationCssClasses, animate: boolean): void;
+    setAlwaysVerticalScrollClass(cssClass: string | null, on: boolean): void;
+    setPinnedTopBottomOverflowY(overflow: 'scroll' | 'hidden'): void;
+    registerBodyViewportResizeListener(listener: () => void): void;
+    setBodyViewportWidth(width: string): void;
+    setGridRootRole(role: 'grid' | 'treegrid'): void;
+}
+export declare class GridBodyCtrl extends BeanStub {
+    private ctrlsSvc;
+    private colModel;
+    private scrollVisibleSvc;
+    private rowGroupColsSvc?;
+    private pinnedRowModel?;
+    private filterManager?;
+    wireBeans(beans: BeanCollection): void;
+    private comp;
+    eGridBody: HTMLElement;
+    eBodyViewport: HTMLElement;
+    private eTop;
+    private eBottom;
+    private eStickyTop;
+    private eCenterColsViewport;
+    private eFullWidthContainer;
+    private eStickyTopFullWidthContainer;
+    private eStickyBottomFullWidthContainer;
+    stickyTopHeight: number;
+    private eStickyBottom;
+    stickyBottomHeight: number;
+    scrollFeature: GridBodyScrollFeature;
+    setComp(comp: IGridBodyComp, eGridBody: HTMLElement, eBodyViewport: HTMLElement, eTop: HTMLElement, eBottom: HTMLElement, eStickyTop: HTMLElement, eStickyBottom: HTMLElement): void;
+    private addEventListeners;
+    private onGridColumnsChanged;
+    private onScrollVisibilityChanged;
+    private setGridRootRole;
+    private addFocusListeners;
+    setColumnMovingCss(moving: boolean): void;
+    setCellTextSelection(selectable?: boolean): void;
+    private updateScrollingClasses;
+    private disableBrowserDragging;
+    private addStopEditingWhenGridLosesFocus;
+    updateRowCount(): void;
+    registerBodyViewportResizeListener(listener: () => void): void;
+    setVerticalScrollPaddingVisible(visible: boolean): void;
+    isVerticalScrollShowing(): boolean;
+    private setupRowAnimationCssClass;
+    private addBodyViewportListener;
+    private addFullWidthContainerWheelListener;
+    private onFullWidthContainerWheel;
+    private onStickyWheel;
+    private scrollGridBodyToMatchEvent;
+    private onBodyViewportContextMenu;
+    private onBodyViewportWheel;
+    scrollVertically(pixels: number): number;
+    private setFloatingHeights;
+    setStickyTopHeight(height?: number): void;
+    setStickyBottomHeight(height?: number): void;
+    private setStickyWidth;
+    private setStickyTopOffsetTop;
+    private setStickyBottomOffsetBottom;
+}

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

@@ -0,0 +1,71 @@
+import { BeanStub } from '../context/beanStub';
+import type { BeanCollection } from '../context/context';
+import type { IRowNode, VerticalScrollPosition } from '../interfaces/iRowNode';
+export interface ScrollPartner {
+    eViewport: HTMLElement;
+    onScrollCallback(fn: () => void): void;
+}
+export declare class GridBodyScrollFeature extends BeanStub {
+    private ctrlsSvc;
+    private animationFrameSvc?;
+    private visibleCols;
+    wireBeans(beans: BeanCollection): void;
+    private enableRtl;
+    private lastScrollSource;
+    private eBodyViewport;
+    private scrollLeft;
+    private nextScrollTop;
+    private scrollTop;
+    private lastOffsetHeight;
+    private lastScrollTop;
+    private scrollTimer;
+    private needsRefreshedScrollPosition;
+    private readonly resetLastHScrollDebounced;
+    private readonly resetLastVScrollDebounced;
+    private centerRowsCtrl;
+    constructor(eBodyViewport: HTMLElement);
+    destroy(): void;
+    postConstruct(): void;
+    private requireUpdatedScrollPosition;
+    private addScrollListener;
+    private addHorizontalScrollListeners;
+    private addVerticalScrollListeners;
+    private registerScrollPartner;
+    private onDisplayedColumnsWidthChanged;
+    private horizontallyScrollHeaderCenterAndFloatingCenter;
+    private setScrollLeftForAllContainersExceptCurrent;
+    private getViewportForSource;
+    private isControllingScroll;
+    private onHScroll;
+    private onVScroll;
+    private doHorizontalScroll;
+    private fireScrollEvent;
+    private shouldBlockScrollUpdate;
+    private shouldBlockVerticalScroll;
+    private shouldBlockHorizontalScroll;
+    private redrawRowsAfterScroll;
+    checkScrollLeft(): void;
+    scrollGridIfNeeded(): boolean;
+    setHorizontalScrollPosition(hScrollPosition: number, fromAlignedGridsService?: boolean): void;
+    setVerticalScrollPosition(vScrollPosition: number): void;
+    getVScrollPosition(): VerticalScrollPosition;
+    /** Get an approximate scroll position that returns the last real value read.
+     * This is useful for avoiding repeated DOM reads that force the browser to recalculate styles.
+     * This can have big performance improvements but may not be 100% accurate so only use if this is acceptable.
+     */
+    getApproximateVScollPosition(): VerticalScrollPosition;
+    getHScrollPosition(): {
+        left: number;
+        right: number;
+    };
+    isHorizontalScrollShowing(): boolean;
+    scrollHorizontally(pixels: number): number;
+    scrollToTop(): void;
+    ensureNodeVisible<TData = any>(comparator: TData | IRowNode<TData> | ((row: IRowNode<TData>) => boolean), position?: 'top' | 'bottom' | 'middle' | null): void;
+    ensureIndexVisible(index: number, position?: 'top' | 'bottom' | 'middle' | null): void;
+    ensureColumnVisible(key: any, position?: 'auto' | 'start' | 'middle' | 'end'): void;
+    private getPositionedHorizontalScroll;
+    private isColumnOutsideViewport;
+    private getColumnBounds;
+    private getViewportBounds;
+}

package/dist/types/src/gridBodyComp/mouseEventUtils.d.ts

@@ -0,0 +1,12 @@
+import type { BeanCollection } from '../context/context';
+import type { DraggingEvent } from '../dragAndDrop/dragAndDropService';
+import type { GridOptionsService } from '../gridOptionsService';
+import type { CellPosition } from '../interfaces/iCellPosition';
+export declare function _stampTopLevelGridCompWithGridInstance(gos: GridOptionsService, eGridDiv: HTMLElement): void;
+export declare function _isEventFromThisGrid(gos: GridOptionsService, event: UIEvent): boolean;
+export declare function _isElementInThisGrid(gos: GridOptionsService, element: HTMLElement): boolean;
+export declare function _getCellPositionForEvent(gos: GridOptionsService, event: MouseEvent | KeyboardEvent): CellPosition | null;
+export declare function _getNormalisedMousePosition(beans: BeanCollection, event: MouseEvent | DraggingEvent): {
+    x: number;
+    y: number;
+};

package/dist/types/src/gridBodyComp/rowContainer/rowContainerComp.d.ts

@@ -0,0 +1,20 @@
+import type { ComponentSelector } from '../../widgets/component';
+import { Component } from '../../widgets/component';
+export declare class RowContainerComp extends Component {
+    private readonly eViewport;
+    private readonly eContainer;
+    private readonly name;
+    private readonly options;
+    private rowComps;
+    private domOrder;
+    private lastPlacedElement;
+    constructor(params?: {
+        name: string;
+    });
+    postConstruct(): void;
+    destroy(): void;
+    private setRowCtrls;
+    appendRow(element: HTMLElement): void;
+    private ensureDomOrder;
+}
+export declare const RowContainerSelector: ComponentSelector;

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

@@ -0,0 +1,71 @@
+import { BeanStub } from '../../context/beanStub';
+import type { ColumnPinnedType } from '../../interfaces/iColumn';
+import type { RowCtrl } from '../../rendering/row/rowCtrl';
+import type { RowRenderer } from '../../rendering/rowRenderer';
+import type { ScrollPartner } from '../gridBodyScrollFeature';
+import { ViewportSizeFeature } from '../viewportSizeFeature';
+export type RowContainerName = 'left' | 'right' | 'center' | 'fullWidth' | 'topLeft' | 'topRight' | 'topCenter' | 'topFullWidth' | 'stickyTopLeft' | 'stickyTopRight' | 'stickyTopCenter' | 'stickyTopFullWidth' | 'stickyBottomLeft' | 'stickyBottomRight' | 'stickyBottomCenter' | 'stickyBottomFullWidth' | 'bottomLeft' | 'bottomRight' | 'bottomCenter' | 'bottomFullWidth';
+export type RowContainerType = 'left' | 'right' | 'center' | 'fullWidth';
+type GetRowCtrls = (renderer: RowRenderer) => RowCtrl[];
+export type RowContainerOptions = {
+    type: RowContainerType;
+    container: string;
+    viewport?: string;
+    pinnedType?: ColumnPinnedType;
+    fullWidth?: boolean;
+    getRowCtrls: GetRowCtrls;
+};
+export declare function _getRowContainerOptions(name: RowContainerName): RowContainerOptions;
+export interface IRowContainerComp {
+    setViewportHeight(height: string): void;
+    setHorizontalScroll(offset: number): void;
+    setRowCtrls(params: {
+        rowCtrls: RowCtrl[];
+        useFlushSync?: boolean;
+    }): void;
+    setDomOrder(domOrder: boolean): void;
+    setContainerWidth(width: string): void;
+    setOffsetTop(offset: string): void;
+}
+export declare class RowContainerCtrl extends BeanStub implements ScrollPartner {
+    private readonly name;
+    private readonly options;
+    private comp;
+    eContainer: HTMLElement;
+    eViewport: HTMLElement;
+    private enableRtl;
+    viewportSizeFeature: ViewportSizeFeature | undefined;
+    private pinnedWidthFeature;
+    private visible;
+    private EMPTY_CTRLS;
+    constructor(name: RowContainerName);
+    postConstruct(): void;
+    private onStickyTopOffsetChanged;
+    private registerWithCtrlsService;
+    private forContainers;
+    setComp(view: IRowContainerComp, eContainer: HTMLElement, eViewport: HTMLElement): void;
+    onScrollCallback(fn: () => void): void;
+    private addListeners;
+    private listenOnDomOrder;
+    onDisplayedColumnsChanged(): void;
+    private addPreventScrollWhileDragging;
+    onHorizontalViewportChanged(afterScroll?: boolean): void;
+    hasHorizontalScrollGap(): boolean;
+    hasVerticalScrollGap(): boolean;
+    getCenterWidth(): number;
+    getCenterViewportScrollLeft(): number;
+    registerViewportResizeListener(listener: () => void): void;
+    isViewportInTheDOMTree(): boolean;
+    getViewportScrollLeft(): number;
+    isHorizontalScrollShowing(): boolean;
+    setHorizontalScroll(offset: number): void;
+    getHScrollPosition(): {
+        left: number;
+        right: number;
+    };
+    setCenterViewportScrollLeft(value: number): void;
+    private isContainerVisible;
+    private onPinnedWidthChanged;
+    private onDisplayedRowsChanged;
+}
+export {};

package/dist/types/src/gridBodyComp/rowContainer/rowContainerEventsFeature.d.ts

@@ -0,0 +1,26 @@
+import { BeanStub } from '../../context/beanStub';
+import type { CellCtrl } from '../../rendering/cell/cellCtrl';
+import type { RowCtrl } from '../../rendering/row/rowCtrl';
+export declare class RowContainerEventsFeature extends BeanStub {
+    readonly element: HTMLElement;
+    constructor(element: HTMLElement);
+    postConstruct(): void;
+    private addKeyboardListeners;
+    private addMouseListeners;
+    private processMouseEvent;
+    getControlsForEventTarget(target: EventTarget | null): {
+        cellCtrl: CellCtrl | null;
+        rowCtrl: RowCtrl | null;
+    };
+    private processKeyboardEvent;
+    private processCellKeyboardEvent;
+    private processFullWidthRowKeyboardEvent;
+    private doGridOperations;
+    private onCtrlAndA;
+    private onCtrlAndC;
+    private onCtrlAndX;
+    private onCtrlAndV;
+    private onCtrlAndD;
+    private onCtrlAndZ;
+    private onCtrlAndY;
+}

package/dist/types/src/gridBodyComp/rowContainer/setHeightFeature.d.ts

@@ -0,0 +1,8 @@
+import { BeanStub } from '../../context/beanStub';
+export declare class SetHeightFeature extends BeanStub {
+    private readonly eContainer;
+    private readonly eViewport?;
+    constructor(eContainer: HTMLElement, eViewport?: HTMLElement | undefined);
+    postConstruct(): void;
+    private onHeightChanged;
+}

package/dist/types/src/gridBodyComp/rowContainer/setPinnedWidthFeature.d.ts

@@ -0,0 +1,9 @@
+import { BeanStub } from '../../context/beanStub';
+export declare class SetPinnedWidthFeature extends BeanStub {
+    private readonly element;
+    private readonly isLeft;
+    readonly getWidth: () => number;
+    constructor(element: HTMLElement, isLeft: boolean);
+    postConstruct(): void;
+    private onPinnedWidthChanged;
+}

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

@@ -0,0 +1,24 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { BeanCollection } from '../context/context';
+export interface SetScrollsVisibleParams {
+    horizontalScrollShowing: boolean;
+    verticalScrollShowing: boolean;
+}
+export declare class ScrollVisibleService extends BeanStub implements NamedBean {
+    beanName: "scrollVisibleSvc";
+    private ctrlsSvc;
+    private colAnimation?;
+    private scrollbarWidth;
+    wireBeans(beans: BeanCollection): void;
+    horizontalScrollShowing: boolean;
+    verticalScrollShowing: boolean;
+    horizontalScrollGap: boolean;
+    verticalScrollGap: boolean;
+    postConstruct(): void;
+    private updateScrollVisible;
+    private updateScrollVisibleImpl;
+    updateScrollGap(): void;
+    setScrollsVisible(params: SetScrollsVisibleParams): void;
+    getScrollbarWidth(): number;
+}

package/dist/types/src/gridBodyComp/viewportSizeFeature.d.ts

@@ -0,0 +1,22 @@
+import { BeanStub } from '../context/beanStub';
+import type { BeanCollection } from '../context/context';
+import type { RowContainerCtrl } from './rowContainer/rowContainerCtrl';
+export declare class ViewportSizeFeature extends BeanStub {
+    private readonly centerContainerCtrl;
+    private scrollVisibleSvc;
+    wireBeans(beans: BeanCollection): void;
+    private gridBodyCtrl;
+    private centerWidth;
+    private bodyHeight;
+    constructor(centerContainerCtrl: RowContainerCtrl);
+    postConstruct(): void;
+    private listenForResize;
+    private onScrollbarWidthChanged;
+    private onCenterViewportResized;
+    private checkViewportAndScrolls;
+    getBodyHeight(): number;
+    private checkBodyHeight;
+    private updateScrollVisibleService;
+    private updateScrollVisibleServiceImpl;
+    private onHorizontalViewportChanged;
+}

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

@@ -0,0 +1,43 @@
+import { BeanStub } from '../context/beanStub';
+import type { FocusableContainer } from '../interfaces/iFocusableContainer';
+import type { LayoutView } from '../styling/layoutFeature';
+import type { ComponentSelector } from '../widgets/component';
+export interface IGridComp extends LayoutView {
+    setRtlClass(cssClass: string): void;
+    destroyGridUi(): void;
+    forceFocusOutOfContainer(up: boolean): void;
+    getFocusableContainers(): FocusableContainer[];
+    setCursor(value: string | null): void;
+    setUserSelect(value: string | null): void;
+}
+export interface OptionalGridComponents {
+    paginationSelector?: ComponentSelector;
+    gridHeaderDropZonesSelector?: ComponentSelector;
+    sideBarSelector?: ComponentSelector;
+    statusBarSelector?: ComponentSelector;
+    watermarkSelector?: ComponentSelector;
+}
+export declare class GridCtrl extends BeanStub {
+    private view;
+    private eGridHostDiv;
+    private eGui;
+    private additionalFocusableContainers;
+    setComp(view: IGridComp, eGridDiv: HTMLElement, eGui: HTMLElement): void;
+    isDetailGrid(): boolean;
+    getOptionalSelectors(): OptionalGridComponents;
+    private onGridSizeChanged;
+    destroyGridUi(): void;
+    getGui(): HTMLElement;
+    setResizeCursor(on: boolean): void;
+    disableUserSelect(on: boolean): void;
+    focusNextInnerContainer(backwards: boolean): boolean;
+    focusInnerElement(fromBottom?: boolean): boolean;
+    forceFocusOutOfContainer(up?: boolean): void;
+    addFocusableContainer(container: FocusableContainer): void;
+    removeFocusableContainer(container: FocusableContainer): void;
+    allowFocusForNextCoreContainer(up?: boolean): void;
+    private getNextFocusableIndex;
+    private focusContainer;
+    private getFocusableContainers;
+    destroy(): void;
+}

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

@@ -0,0 +1,6 @@
+import type { _CoreGridApi } from './api/gridApi';
+import type { _ModuleWithApi } from './interfaces/iModule';
+/**
+ * @internal
+ */
+export declare const CommunityCoreModule: _ModuleWithApi<_CoreGridApi>;

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

@@ -0,0 +1,7 @@
+import type { NamedBean } from './context/bean';
+import { BeanStub } from './context/beanStub';
+export declare class GridDestroyService extends BeanStub implements NamedBean {
+    beanName: "gridDestroySvc";
+    destroyCalled: boolean;
+    destroy(): void;
+}

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

@@ -0,0 +1,173 @@
+import type { GridOptions } from './entities/gridOptions';
+export declare const GRID_OPTION_DEFAULTS: {
+    readonly suppressContextMenu: false;
+    readonly preventDefaultOnContextMenu: false;
+    readonly allowContextMenuWithControlKey: false;
+    readonly suppressMenuHide: true;
+    readonly enableBrowserTooltips: false;
+    readonly tooltipTrigger: "hover";
+    readonly tooltipShowDelay: 2000;
+    readonly tooltipHideDelay: 10000;
+    readonly tooltipMouseTrack: false;
+    readonly tooltipShowMode: "standard";
+    readonly tooltipInteraction: false;
+    readonly copyHeadersToClipboard: false;
+    readonly copyGroupHeadersToClipboard: false;
+    readonly clipboardDelimiter: "\t";
+    readonly suppressCopyRowsToClipboard: false;
+    readonly suppressCopySingleCellRanges: false;
+    readonly suppressLastEmptyLineOnPaste: false;
+    readonly suppressClipboardPaste: false;
+    readonly suppressClipboardApi: false;
+    readonly suppressCutToClipboard: false;
+    readonly maintainColumnOrder: false;
+    readonly enableStrictPivotColumnOrder: false;
+    readonly suppressFieldDotNotation: false;
+    readonly allowDragFromColumnsToolPanel: false;
+    readonly suppressMovableColumns: false;
+    readonly suppressColumnMoveAnimation: false;
+    readonly suppressMoveWhenColumnDragging: false;
+    readonly suppressDragLeaveHidesColumns: false;
+    readonly suppressRowGroupHidesColumns: false;
+    readonly suppressAutoSize: false;
+    readonly autoSizePadding: 20;
+    readonly skipHeaderOnAutoSize: false;
+    readonly singleClickEdit: false;
+    readonly suppressClickEdit: false;
+    readonly readOnlyEdit: false;
+    readonly stopEditingWhenCellsLoseFocus: false;
+    readonly enterNavigatesVertically: false;
+    readonly enterNavigatesVerticallyAfterEdit: false;
+    readonly enableCellEditingOnBackspace: false;
+    readonly undoRedoCellEditing: false;
+    readonly undoRedoCellEditingLimit: 10;
+    readonly suppressCsvExport: false;
+    readonly suppressExcelExport: false;
+    readonly cacheQuickFilter: false;
+    readonly includeHiddenColumnsInQuickFilter: false;
+    readonly excludeChildrenWhenTreeDataFiltering: false;
+    readonly enableAdvancedFilter: false;
+    readonly includeHiddenColumnsInAdvancedFilter: false;
+    readonly enableCharts: false;
+    readonly masterDetail: false;
+    readonly keepDetailRows: false;
+    readonly keepDetailRowsCount: 10;
+    readonly detailRowAutoHeight: false;
+    readonly tabIndex: 0;
+    readonly rowBuffer: 10;
+    readonly valueCache: false;
+    readonly valueCacheNeverExpires: false;
+    readonly enableCellExpressions: false;
+    readonly suppressTouch: false;
+    readonly suppressFocusAfterRefresh: false;
+    readonly suppressBrowserResizeObserver: false;
+    readonly suppressPropertyNamesCheck: false;
+    readonly suppressChangeDetection: false;
+    readonly debug: false;
+    readonly suppressLoadingOverlay: false;
+    readonly suppressNoRowsOverlay: false;
+    readonly pagination: false;
+    readonly paginationPageSize: 100;
+    readonly paginationPageSizeSelector: true;
+    readonly paginationAutoPageSize: false;
+    readonly paginateChildRows: false;
+    readonly suppressPaginationPanel: false;
+    readonly pivotMode: false;
+    readonly pivotPanelShow: "never";
+    readonly pivotDefaultExpanded: 0;
+    readonly pivotSuppressAutoColumn: false;
+    readonly suppressExpandablePivotGroups: false;
+    readonly functionsReadOnly: false;
+    readonly suppressAggFuncInHeader: false;
+    readonly alwaysAggregateAtRootLevel: false;
+    readonly aggregateOnlyChangedColumns: false;
+    readonly suppressAggFilteredOnly: false;
+    readonly removePivotHeaderRowWhenSingleValueColumn: false;
+    readonly animateRows: true;
+    readonly cellFlashDuration: 500;
+    readonly cellFadeDuration: 1000;
+    readonly allowShowChangeAfterFilter: false;
+    readonly domLayout: "normal";
+    readonly ensureDomOrder: false;
+    readonly enableRtl: false;
+    readonly suppressColumnVirtualisation: false;
+    readonly suppressMaxRenderedRowRestriction: false;
+    readonly suppressRowVirtualisation: false;
+    readonly rowDragManaged: false;
+    readonly suppressRowDrag: false;
+    readonly suppressMoveWhenRowDragging: false;
+    readonly rowDragEntireRow: false;
+    readonly rowDragMultiRow: false;
+    readonly embedFullWidthRows: false;
+    readonly groupDisplayType: "singleColumn";
+    readonly groupDefaultExpanded: 0;
+    readonly groupMaintainOrder: false;
+    readonly groupSelectsChildren: false;
+    readonly groupSuppressBlankHeader: false;
+    readonly groupSelectsFiltered: false;
+    readonly showOpenedGroup: false;
+    readonly groupRemoveSingleChildren: false;
+    readonly groupRemoveLowestSingleChildren: false;
+    readonly groupHideOpenParents: false;
+    readonly groupAllowUnbalanced: false;
+    readonly rowGroupPanelShow: "never";
+    readonly suppressMakeColumnVisibleAfterUnGroup: false;
+    readonly treeData: false;
+    readonly rowGroupPanelSuppressSort: false;
+    readonly suppressGroupRowsSticky: false;
+    readonly rowModelType: "clientSide";
+    readonly asyncTransactionWaitMillis: 50;
+    readonly suppressModelUpdateAfterUpdateTransaction: false;
+    readonly cacheOverflowSize: 1;
+    readonly infiniteInitialRowCount: 1;
+    readonly serverSideInitialRowCount: 1;
+    readonly cacheBlockSize: 100;
+    readonly maxBlocksInCache: -1;
+    readonly maxConcurrentDatasourceRequests: 2;
+    readonly blockLoadDebounceMillis: 0;
+    readonly purgeClosedRowNodes: false;
+    readonly serverSideSortAllLevels: false;
+    readonly serverSideOnlyRefreshFilteredGroups: false;
+    readonly serverSidePivotResultFieldSeparator: "_";
+    readonly viewportRowModelPageSize: 5;
+    readonly viewportRowModelBufferSize: 5;
+    readonly alwaysShowHorizontalScroll: false;
+    readonly alwaysShowVerticalScroll: false;
+    readonly debounceVerticalScrollbar: false;
+    readonly suppressHorizontalScroll: false;
+    readonly suppressScrollOnNewData: false;
+    readonly suppressScrollWhenPopupsAreOpen: false;
+    readonly suppressAnimationFrame: false;
+    readonly suppressMiddleClickScrolls: false;
+    readonly suppressPreventDefaultOnMouseWheel: false;
+    readonly rowMultiSelectWithClick: false;
+    readonly suppressRowDeselection: false;
+    readonly suppressRowClickSelection: false;
+    readonly suppressCellFocus: false;
+    readonly suppressHeaderFocus: false;
+    readonly suppressMultiRangeSelection: false;
+    readonly enableCellTextSelection: false;
+    readonly enableRangeSelection: false;
+    readonly enableRangeHandle: false;
+    readonly enableFillHandle: false;
+    readonly fillHandleDirection: "xy";
+    readonly suppressClearOnFillReduction: false;
+    readonly accentedSort: false;
+    readonly unSortIcon: false;
+    readonly suppressMultiSort: false;
+    readonly alwaysMultiSort: false;
+    readonly suppressMaintainUnsortedOrder: false;
+    readonly suppressRowHoverHighlight: false;
+    readonly suppressRowTransform: false;
+    readonly columnHoverHighlight: false;
+    readonly deltaSort: false;
+    readonly enableGroupEdit: false;
+    readonly groupLockGroupColumns: 0;
+    readonly serverSideEnableClientSideSort: false;
+    readonly suppressServerSideFullWidthLoadingRow: false;
+    readonly pivotMaxGeneratedColumns: -1;
+    readonly columnMenu: "new";
+    readonly reactiveCustomComponents: true;
+    readonly suppressSetFilterByDefault: false;
+};
+export type GridOptionOrDefault<K extends keyof GridOptions> = K extends keyof typeof GRID_OPTION_DEFAULTS ? NonNullable<GridOptions[K]> : GridOptions[K];