@agile-team/mach-table 0.4.0

package/dist/index.d.ts

@@ -0,0 +1,1939 @@
+declare class ColumnGroup<TData = any> {
+    readonly groupId: string;
+    readonly def: ColDefGroup<TData>;
+    parent: ColumnGroup<TData> | null;
+    children: (ColumnGroup<TData> | Column<TData>)[];
+    constructor(groupId: string, def: ColDefGroup<TData>);
+    get headerName(): string;
+    getLeafColumns(out?: Column<TData>[]): Column<TData>[];
+}
+
+declare class Column<TData = any> {
+    readonly id: string;
+    readonly colDef: ColDef<TData>;
+    hide: boolean;
+    pinned: PinnedDirection | null;
+    manualWidth: number | null;
+    currentWidth: number;
+    parentGroup: ColumnGroup<TData> | null;
+    level: number;
+    isDetailToggle: boolean;
+    constructor(id: string, colDef: ColDef<TData>);
+    get sortable(): boolean;
+    get resizable(): boolean;
+    get movable(): boolean;
+    get filterable(): boolean;
+    get filterType(): FilterType;
+    get hasCheckbox(): boolean;
+}
+
+interface RowNode<TData = any> {
+    id: string;
+    data: TData | null;
+    rowIndex: number;
+    selected: boolean;
+    isDetail?: boolean;
+    masterId?: string;
+    isGroup?: boolean;
+    groupLevel?: number;
+    groupKey?: string;
+    leafNodes?: RowNode<TData>[];
+    aggValues?: Record<string, any>;
+}
+
+declare const EVENT_TYPES: readonly ["gridReady", "gridDestroyed", "modelUpdated", "cellClicked", "cellDoubleClicked", "cellContextMenu", "rowClicked", "rowDoubleClicked", "selectionChanged", "sortChanged", "filterChanged", "columnResized", "columnMoved", "columnVisibilityChanged", "cellValueChanged", "cellEditingStarted", "cellEditingStopped", "detailToggled", "rowDragEnd", "rangeSelectionChanged", "paginationChanged", "displayedColumnsChanged", "gridError"];
+type GridEventType = (typeof EVENT_TYPES)[number];
+interface GridEventBase {
+    type: GridEventType;
+    api: GridApi<any>;
+}
+interface GridReadyEvent extends GridEventBase {
+    type: "gridReady";
+}
+interface GridDestroyedEvent extends GridEventBase {
+    type: "gridDestroyed";
+}
+interface ModelUpdatedEvent extends GridEventBase {
+    type: "modelUpdated";
+    rowCount: number;
+}
+interface CellClickEvent<TData = any, TValue = any> extends GridEventBase {
+    type: "cellClicked";
+    event: MouseEvent;
+    rowNode: RowNode<TData>;
+    rowIndex: number;
+    column: Column<TData>;
+    colDef: ColDef<TData, TValue>;
+    value: TValue;
+}
+interface CellDoubleClickEvent<TData = any, TValue = any> extends GridEventBase {
+    type: "cellDoubleClicked";
+    event: MouseEvent;
+    rowNode: RowNode<TData>;
+    rowIndex: number;
+    column: Column<TData>;
+    colDef: ColDef<TData, TValue>;
+    value: TValue;
+}
+interface CellContextMenuEvent<TData = any, TValue = any> extends GridEventBase {
+    type: "cellContextMenu";
+    event: MouseEvent;
+    rowNode: RowNode<TData>;
+    rowIndex: number;
+    column: Column<TData>;
+    colDef: ColDef<TData, TValue>;
+    value: TValue;
+}
+interface RowClickEvent<TData = any> extends GridEventBase {
+    type: "rowClicked" | "rowDoubleClicked";
+    event: MouseEvent;
+    rowNode: RowNode<TData>;
+    rowIndex: number;
+}
+interface SelectionChangedEvent<TData = any> extends GridEventBase {
+    type: "selectionChanged";
+    selectedNodes: RowNode<TData>[];
+    selectedRows: TData[];
+}
+interface SortChangedEvent extends GridEventBase {
+    type: "sortChanged";
+    sortModel: SortModel;
+}
+interface FilterChangedEvent extends GridEventBase {
+    type: "filterChanged";
+    filterModel: FilterModel;
+}
+interface ColumnResizedEvent extends GridEventBase {
+    type: "columnResized";
+    colId: string;
+    width: number;
+    finished: boolean;
+}
+interface ColumnMovedEvent extends GridEventBase {
+    type: "columnMoved";
+    colId: string;
+    toIndex: number;
+}
+interface ColumnVisibilityChangedEvent extends GridEventBase {
+    type: "columnVisibilityChanged";
+    colId: string;
+    visible: boolean;
+}
+interface CellValueChangedEvent<TData = any, TValue = any> extends GridEventBase {
+    type: "cellValueChanged";
+    oldValue: TValue;
+    newValue: TValue;
+    rowNode: RowNode<TData>;
+    rowIndex: number;
+    column: Column<TData>;
+    colDef: ColDef<TData, TValue>;
+    data: TData;
+}
+interface CellEditingStartedEvent<TData = any> extends GridEventBase {
+    type: "cellEditingStarted";
+    rowIndex: number;
+    colId: string;
+    rowNode: RowNode<TData>;
+}
+interface CellEditingStoppedEvent<TData = any> extends GridEventBase {
+    type: "cellEditingStopped";
+    rowIndex: number;
+    colId: string;
+    rowNode: RowNode<TData>;
+    oldValue: any;
+    newValue: any;
+}
+interface DetailToggledEvent<TData = any> extends GridEventBase {
+    type: "detailToggled";
+    rowId: string;
+    rowNode: RowNode<TData>;
+    expanded: boolean;
+}
+interface GridCellRange {
+    row1: number;
+    row2: number;
+    colId1: string;
+    colId2: string;
+}
+interface RangeSelectionChangedEvent extends GridEventBase {
+    type: "rangeSelectionChanged";
+    range: GridCellRange | null;
+}
+interface RowDragEndEvent<TData = any> extends GridEventBase {
+    type: "rowDragEnd";
+    rowNode: RowNode<TData>;
+    fromIndex: number;
+    toIndex: number;
+}
+interface PaginationChangedEvent extends GridEventBase {
+    type: "paginationChanged";
+    page: number;
+    pageSize: number;
+    pageCount: number;
+    total: number;
+}
+interface DisplayedColumnsChangedEvent extends GridEventBase {
+    type: "displayedColumnsChanged";
+}
+interface GridErrorEvent extends GridEventBase {
+    type: "gridError";
+    error: unknown;
+    source: string;
+    context?: Record<string, unknown>;
+}
+interface GridEventMap<TData = any> {
+    gridReady: GridReadyEvent;
+    gridDestroyed: GridDestroyedEvent;
+    modelUpdated: ModelUpdatedEvent;
+    cellClicked: CellClickEvent<TData>;
+    cellDoubleClicked: CellDoubleClickEvent<TData>;
+    cellContextMenu: CellContextMenuEvent<TData>;
+    rowClicked: RowClickEvent<TData>;
+    rowDoubleClicked: RowClickEvent<TData>;
+    selectionChanged: SelectionChangedEvent<TData>;
+    sortChanged: SortChangedEvent;
+    filterChanged: FilterChangedEvent;
+    columnResized: ColumnResizedEvent;
+    columnMoved: ColumnMovedEvent;
+    columnVisibilityChanged: ColumnVisibilityChangedEvent;
+    cellValueChanged: CellValueChangedEvent<TData>;
+    cellEditingStarted: CellEditingStartedEvent<TData>;
+    cellEditingStopped: CellEditingStoppedEvent<TData>;
+    detailToggled: DetailToggledEvent<TData>;
+    rowDragEnd: RowDragEndEvent<TData>;
+    rangeSelectionChanged: RangeSelectionChangedEvent;
+    paginationChanged: PaginationChangedEvent;
+    displayedColumnsChanged: DisplayedColumnsChangedEvent;
+    gridError: GridErrorEvent;
+}
+
+declare const DEFAULT_LOCALE: {
+    readonly matchContains: "包含";
+    readonly matchNotContains: "不包含";
+    readonly matchEquals: "等于";
+    readonly matchNotEquals: "不等于";
+    readonly matchStartsWith: "开头是";
+    readonly matchEndsWith: "结尾是";
+    readonly matchBlank: "为空";
+    readonly matchNotBlank: "不为空";
+    readonly matchLessThan: "小于";
+    readonly matchLessThanOrEqual: "小于等于";
+    readonly matchGreaterThan: "大于";
+    readonly matchGreaterThanOrEqual: "大于等于";
+    readonly matchInRange: "在范围内";
+    readonly apply: "应用";
+    readonly reset: "重置";
+    readonly search: "搜索...";
+    readonly emptySetLabel: "(空)";
+    readonly selectedCount: "已选 {n} 项";
+    readonly sortAsc: "升序";
+    readonly sortDesc: "降序";
+    readonly clearSort: "取消排序";
+    readonly pinLeft: "固定左侧";
+    readonly pinRight: "固定右侧";
+    readonly clearPin: "取消固定";
+    readonly autoSize: "自适应列宽";
+    readonly hideColumn: "隐藏此列";
+    readonly columnVisibility: "列显示";
+    readonly resetAll: "重置全部";
+    readonly autoSizeAll: "全部自适应";
+    readonly columnSettings: "列设置";
+    readonly totalLabel: "合计";
+    readonly totalRowsLabel: "共 {n} 行";
+    readonly menuCopy: "复制";
+    readonly menuPaste: "粘贴";
+    readonly menuClearContents: "清除内容";
+    readonly loading: "加载中...";
+    readonly statusSelected: "已选 {n} 行";
+    readonly statusSum: "和 {n}";
+    readonly statusAvg: "均 {n}";
+    readonly statusCount: "计 {n}";
+    readonly emptyRows: "暂无数据";
+    readonly emptyRowsHint: "没有可显示的行";
+    readonly paginationTotal: "共 {n} 条";
+    readonly paginationPage: "第 {a} / {b} 页";
+    readonly perPage: "{n} 条/页";
+    readonly pageFirst: "首页";
+    readonly pagePrev: "上一页";
+    readonly pageNext: "下一页";
+    readonly pageLast: "末页";
+};
+type RgLocaleKey = keyof typeof DEFAULT_LOCALE;
+type RgLocale = Partial<Record<RgLocaleKey, string>>;
+declare const LOCALE_EN: RgLocale;
+declare function matchLocaleKey(match: string): RgLocaleKey;
+declare function formatText(template: string, n: number | string): string;
+declare function formatTwo(template: string, a: number | string, b: number | string): string;
+
+interface ColumnStateStore {
+    load(key: string): ColumnState[] | null | Promise<ColumnState[] | null>;
+    save(key: string, state: ColumnState[]): void | Promise<void>;
+}
+/** Per-grid component overrides. These take precedence over the global registry. */
+interface GridComponents {
+    cellRenderers?: Readonly<Record<string, CellRendererFn>>;
+    cellEditors?: Readonly<Record<string, CellEditorFactory>>;
+}
+interface GridFeatureContext<TData = any> {
+    readonly api: GridApi<TData>;
+    readonly root: HTMLElement;
+    getOptions(): Readonly<ResolvedGridOptions<TData>>;
+    addEventListener<K extends keyof GridEventMap<TData>>(type: K, listener: (event: GridEventMap<TData>[K]) => void): () => void;
+    reportError(error: unknown, source: string, context?: Record<string, unknown>): void;
+}
+/** Composable extension point; feature instances are scoped to one grid. */
+interface GridFeature<TData = any> {
+    readonly key: string;
+    setup(context: GridFeatureContext<TData>): void | (() => void);
+    destroy?(): void;
+}
+/**
+ * Safe overlay content. Strings render as text unless
+ * `allowUnsafeOverlayHtml` is explicitly enabled.
+ */
+type OverlayTemplate = string | HTMLElement | (() => string | HTMLElement);
+type StatusBarPanel = "rowCount" | "selectedRowCount" | "rangeAggregate";
+interface StatusBarConfig {
+    panels?: StatusBarPanel[];
+}
+interface InfiniteGetRowsParams<TData = any> {
+    startRow: number;
+    endRow: number;
+    sortModel: SortModel;
+    filterModel: FilterModel;
+    quickFilterText: string | null;
+    signal: AbortSignal;
+    onSuccess(rows: TData[], lastRow?: number): void;
+    fail(reason?: unknown): void;
+}
+interface GridDatasource<TData = any> {
+    getRows(params: InfiniteGetRowsParams<TData>): void | Promise<void>;
+}
+type EventHandlers<TData = any> = {
+    [K in keyof GridEventMap<TData> as `on${Capitalize<K & string>}`]?: (event: GridEventMap<TData>[K]) => void;
+};
+type RowSelectionMode = "none" | "single" | "multiple";
+type GridSize = "compact" | "normal" | "large";
+type ThemeMode = "light" | "dark" | "auto";
+interface DetailRowRendererParams<TData = any> {
+    data: TData | null;
+    node: RowNode<TData>;
+    api: GridApi<TData>;
+}
+interface PaginationConfig {
+    pageSize?: number;
+    pageSizeOptions?: number[];
+    showTotal?: boolean;
+    showPageSizeSelector?: boolean;
+}
+interface WatermarkConfig {
+    text: string;
+    fontSize?: number;
+    color?: string;
+    opacity?: number;
+    gap?: number;
+    angle?: number;
+}
+interface GridOptions<TData = any> extends EventHandlers<TData> {
+    columnDefs?: (ColDef<TData> | ColDefGroup<TData>)[] | null;
+    rowData?: TData[] | null;
+    defaultColDef?: Partial<ColDef<TData>>;
+    getRowId?: (params: GetRowIdParams<TData>) => string;
+    rowHeight?: number;
+    headerHeight?: number;
+    rowBuffer?: number;
+    rowSelection?: RowSelectionMode;
+    multiSort?: boolean;
+    size?: GridSize;
+    stripedRows?: boolean;
+    showCellBorders?: boolean;
+    theme?: ThemeMode;
+    quickFilterText?: string | null;
+    masterDetail?: boolean;
+    detailRowHeight?: number;
+    detailRowRenderer?: (params: DetailRowRendererParams<TData>) => string | HTMLElement | ICellRendererResult | null | undefined;
+    isRowExpandable?: (params: DetailRowRendererParams<TData>) => boolean;
+    detailToggleColumn?: boolean;
+    columnMenu?: boolean;
+    columnStateKey?: string | null;
+    columnStateStore?: ColumnStateStore;
+    aggFuncs?: Record<string, (values: any[]) => any>;
+    components?: GridComponents;
+    features?: readonly GridFeature<TData>[];
+    locale?: RgLocale;
+    singleClickEdit?: boolean;
+    manualSorting?: boolean;
+    manualFiltering?: boolean;
+    showSummary?: boolean;
+    summaryMethod?: (params: {
+        colId: string;
+        column: Column<any>;
+        values: any[];
+    }) => string;
+    treeData?: boolean;
+    childrenKey?: string;
+    autoCheckedChildren?: boolean;
+    defaultExpandAll?: boolean;
+    indexOffset?: number;
+    applyRowDrag?: boolean;
+    undoStackSize?: number;
+    getRowHeight?: (params: GetRowHeightParams<TData>) => number;
+    pinnedTopRowData?: TData[] | null;
+    pinnedBottomRowData?: TData[] | null;
+    pagination?: boolean | PaginationConfig;
+    watermark?: boolean | WatermarkConfig;
+    suppressWarnings?: boolean;
+    enableRangeSelection?: boolean;
+    suppressClipboard?: boolean;
+    contextMenu?: boolean;
+    getContextMenuItems?: (params: ContextMenuParams<TData>) => ContextMenuItem[] | null;
+    tooltipComponent?: (params: TooltipParams<TData>) => string | HTMLElement;
+    tooltipShowDelay?: number;
+    flashCells?: boolean;
+    fillHandle?: boolean;
+    statusBar?: boolean | StatusBarConfig;
+    datasource?: GridDatasource<TData>;
+    blockSize?: number;
+    infiniteBufferRows?: number;
+    suppressCellFocus?: boolean;
+    suppressRowHoverHighlight?: boolean;
+    suppressNoRowsOverlay?: boolean;
+    suppressHeaderFocus?: boolean;
+    loading?: boolean;
+    overlayNoRowsTemplate?: OverlayTemplate;
+    overlayLoadingTemplate?: OverlayTemplate;
+    /** Opt in only for trusted overlay strings. Prefer HTMLElement factories. */
+    allowUnsafeOverlayHtml?: boolean;
+    className?: string;
+}
+interface ResolvedGridOptions<TData = any> extends EventHandlers<TData> {
+    columnDefs: (ColDef<TData> | ColDefGroup<TData>)[];
+    rowData: TData[];
+    defaultColDef: Partial<ColDef<TData>>;
+    getRowId?: (params: GetRowIdParams<TData>) => string;
+    rowHeight: number;
+    headerHeight: number;
+    rowBuffer: number;
+    rowSelection: RowSelectionMode;
+    multiSort: boolean;
+    size: GridSize;
+    stripedRows: boolean;
+    showCellBorders: boolean;
+    theme: ThemeMode;
+    quickFilterText: string | null;
+    masterDetail: boolean;
+    detailRowHeight: number;
+    detailRowRenderer?: (params: DetailRowRendererParams<TData>) => string | HTMLElement | ICellRendererResult | null | undefined;
+    isRowExpandable?: (params: DetailRowRendererParams<TData>) => boolean;
+    detailToggleColumn: boolean;
+    columnMenu: boolean;
+    columnStateKey: string | null;
+    columnStateStore?: ColumnStateStore;
+    aggFuncs?: Record<string, (values: any[]) => any>;
+    components?: GridComponents;
+    features: readonly GridFeature<TData>[];
+    locale: RgLocale;
+    singleClickEdit: boolean;
+    manualSorting: boolean;
+    manualFiltering: boolean;
+    showSummary: boolean;
+    summaryMethod?: (params: {
+        colId: string;
+        column: Column<any>;
+        values: any[];
+    }) => string;
+    treeData: boolean;
+    childrenKey: string;
+    autoCheckedChildren: boolean;
+    defaultExpandAll: boolean;
+    indexOffset: number;
+    applyRowDrag: boolean;
+    undoStackSize: number;
+    getRowHeight?: (params: GetRowHeightParams<TData>) => number;
+    pinnedTopRowData: TData[];
+    pinnedBottomRowData: TData[];
+    paginationEnabled: boolean;
+    paginationPageSize: number;
+    paginationPageSizeOptions: number[];
+    paginationShowTotal: boolean;
+    paginationShowSizeSelector: boolean;
+    watermarkEnabled: boolean;
+    watermarkConfig: WatermarkConfig | null;
+    suppressWarnings: boolean;
+    enableRangeSelection: boolean;
+    suppressClipboard: boolean;
+    contextMenu: boolean;
+    getContextMenuItems?: (params: ContextMenuParams<TData>) => ContextMenuItem[] | null;
+    tooltipComponent?: (params: TooltipParams<TData>) => string | HTMLElement;
+    tooltipShowDelay: number;
+    flashCells: boolean;
+    fillHandle: boolean;
+    statusBarEnabled: boolean;
+    statusBarPanels: StatusBarPanel[];
+    datasource?: GridDatasource<TData>;
+    blockSize: number;
+    infiniteBufferRows: number;
+    suppressCellFocus: boolean;
+    suppressRowHoverHighlight: boolean;
+    suppressNoRowsOverlay: boolean;
+    suppressHeaderFocus: boolean;
+    loading: boolean;
+    overlayNoRowsTemplate: OverlayTemplate;
+    overlayLoadingTemplate: OverlayTemplate;
+    allowUnsafeOverlayHtml: boolean;
+    className: string;
+}
+
+interface CsvExportParams {
+    includeHeader?: boolean;
+    columnSeparator?: string;
+    prependBOM?: boolean;
+    onlySelected?: boolean;
+    onlyAllDisplayed?: boolean;
+    protectFormulas?: boolean;
+    headersOnly?: boolean;
+}
+interface ImportCsvOptions {
+    separator?: string;
+    mode?: "replace" | "append" | "paste";
+    headerRowIndex?: number;
+    coerceNumbers?: boolean;
+    parseValue?: (params: {
+        value: string;
+        field: string;
+        rowIndex: number;
+        columnIndex: number;
+    }) => any;
+}
+interface PrintOptions {
+    title?: string;
+    includeHeader?: boolean;
+}
+interface RowTransaction<TData = any> {
+    add?: TData[];
+    addIndex?: number;
+    remove?: TData[];
+    update?: TData[];
+}
+interface GridApi<TData = any> {
+    setRowData(rows: TData[] | null | undefined): void;
+    applyTransaction(transaction: RowTransaction<TData>): void;
+    getColumnDefs(): (ColDef<TData> | ColDefGroup<TData>)[] | null;
+    setColumnDefs(colDefs: (ColDef<TData> | ColDefGroup<TData>)[] | null | undefined): void;
+    getColumnState(): ColumnState[];
+    setColumnState(state: ColumnState[]): void;
+    resetColumnState(): void;
+    setColumnVisibility(colId: string, visible: boolean): void;
+    moveColumn(colId: string, toIndex: number): void;
+    setColumnPinned(colId: string, pinned: "left" | "right" | null): void;
+    sizeColumnsToFit(width?: number): void;
+    autoSizeColumn(colId: string, skipHeader?: boolean): void;
+    autoSizeAllColumns(skipHeader?: boolean): void;
+    getSortModel(): SortModel;
+    setSortModel(sortModel: SortModel | null): void;
+    getFilterModel(): FilterModel;
+    setFilterModel(filterModel: FilterModel | null): void;
+    isColumnFilterPresent(colId: string): boolean;
+    setQuickFilter(text: string | null | undefined): void;
+    getQuickFilter(): string | null;
+    getRowSelection(): RowSelectionMode;
+    setRowSelection(mode: RowSelectionMode): void;
+    getSelectedNodes(): RowNode<TData>[];
+    getSelectedRows(): TData[];
+    selectNodeById(nodeId: string, selected?: boolean, clearOthers?: boolean): void;
+    selectAll(filteredOnly?: boolean): void;
+    deselectAll(): void;
+    getDisplayedRowCount(): number;
+    getRowNode(rowIndex: number): RowNode<TData> | undefined;
+    getNodeById(id: string): RowNode<TData> | undefined;
+    forEachNode(callback: (node: RowNode<TData>, index: number) => void): void;
+    forEachNodeAfterFilterAndSort(callback: (node: RowNode<TData>, index: number) => void): void;
+    scrollToIndex(rowIndex: number, position?: "top" | "bottom" | "middle" | "nearest"): void;
+    expandRow(rowId: string): boolean;
+    collapseRow(rowId: string): boolean;
+    toggleDetailRow(rowId: string): boolean;
+    isRowExpanded(rowId: string): boolean;
+    expandAllDetails(): void;
+    collapseAllDetails(): void;
+    toggleRowGroup(groupId: string): boolean;
+    isGroupExpanded(groupId: string): boolean;
+    expandAllGroups(): void;
+    collapseAllGroups(): void;
+    reorderRows(fromIndex: number, toIndex: number): boolean;
+    setSelection(rows: TData[], clearOthers?: boolean): void;
+    getVisibleSelection(): TData[];
+    getSelectedIds(): string[];
+    undo(): boolean;
+    redo(): boolean;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    setPinnedTopRowData(rows: TData[] | null): void;
+    getPinnedTopRowData(): TData[];
+    setPinnedBottomRowData(rows: TData[] | null): void;
+    getPinnedBottomRowData(): TData[];
+    getRangeSelection(): GridCellRange | null;
+    clearRangeSelection(): void;
+    copyRangeToClipboard(): Promise<boolean>;
+    openColumnPanel(anchor?: HTMLElement): void;
+    refreshLayout(): void;
+    isInfinite(): boolean;
+    reload(): Promise<void>;
+    paginationEnabled(): boolean;
+    setPaginationEnabled(enabled: boolean): void;
+    getPage(): number;
+    setPage(page: number): void;
+    getPageSize(): number;
+    setPageSize(size: number): void;
+    getPageCount(): number;
+    getTotalRowCount(): number;
+    importCsv(text: string, options?: ImportCsvOptions): boolean;
+    print(options?: PrintOptions): boolean;
+    startEditingCell(params: {
+        rowIndex: number;
+        colId: string;
+        keyPress?: string;
+    }): boolean;
+    stopEditing(cancel?: boolean): void;
+    refreshCells(): void;
+    updateOptions(options: Partial<GridOptions<TData>>): void;
+    getDataAsCsv(params?: CsvExportParams): string;
+    setOverlay(type: "loading" | "noRows" | null): void;
+    hideOverlays(): void;
+    addEventListener<K extends GridEventType>(eventType: K, listener: (event: GridEventMap<TData>[K]) => void): () => void;
+    removeEventListener<K extends GridEventType>(eventType: K, listener: (event: GridEventMap<TData>[K]) => void): void;
+    destroy(): void;
+    isDestroyed(): boolean;
+}
+
+interface ValueGetterParams<TData = any, TValue = any> {
+    data: TData | null;
+    node: RowNode<TData>;
+    colDef: ColDef<TData, TValue>;
+    column: Column<TData>;
+    api: GridApi<TData>;
+}
+interface ValueFormatterParams<TData = any, TValue = any> extends ValueGetterParams<TData, TValue> {
+    value: TValue;
+}
+interface CellRendererParams<TData = any, TValue = any> extends ValueGetterParams<TData, TValue> {
+    value: TValue;
+    formatted: string;
+    rowIndex: number;
+    rendererParams?: Record<string, any>;
+}
+interface CellClassParams<TData = any, TValue = any> extends ValueGetterParams<TData, TValue> {
+    value: TValue;
+    rowIndex: number;
+}
+interface EditableParams<TData = any, TValue = any> extends ValueGetterParams<TData, TValue> {
+    value: TValue;
+    rowIndex: number;
+}
+interface CellEditorParams<TData = any, TValue = any> extends ValueGetterParams<TData, TValue> {
+    value: TValue;
+    rowIndex: number;
+    keyPress?: string | null;
+}
+interface ValueSetterParams<TData = any, TValue = any> {
+    oldValue: TValue;
+    newValue: TValue;
+    data: TData;
+    node: RowNode<TData>;
+    colDef: ColDef<TData, TValue>;
+    column: Column<TData>;
+    api: GridApi<TData>;
+}
+interface GetRowIdParams<TData = any> {
+    data: TData;
+    index: number;
+    api: GridApi<TData>;
+}
+interface GetRowHeightParams<TData = any> {
+    data: TData | null;
+    node: RowNode<TData>;
+    api: GridApi<TData>;
+}
+interface TooltipParams<TData = any> {
+    data: TData | null;
+    node: RowNode<TData>;
+    api: GridApi<TData>;
+    colId: string;
+    value: any;
+    formatted: string;
+    rowIndex: number;
+}
+interface ContextMenuParams<TData = any> {
+    data: TData | null;
+    node: RowNode<TData>;
+    api: GridApi<TData>;
+    colId: string;
+    value: any;
+    rowIndex: number;
+}
+interface ContextMenuItem {
+    label?: string;
+    action?: () => void;
+    danger?: boolean;
+    disabled?: boolean;
+    separator?: boolean;
+}
+interface HeaderComponentParams<TData = any> {
+    colDef: ColDef<TData>;
+    column: Column<TData>;
+    api: GridApi<TData>;
+}
+interface ICellRendererResult {
+    el: HTMLElement;
+    destroy?: () => void;
+}
+type CellRendererOutput = string | HTMLElement | ICellRendererResult | null | undefined;
+interface ICellEditor<TValue = any> {
+    el: HTMLElement;
+    getValue(): TValue | null | undefined;
+    focus?(): void;
+    destroy?(): void;
+    isCancelBeforeStart?(): boolean;
+    isCancelAfterEnd?(value: TValue | null | undefined): boolean;
+}
+
+type SortDirection = "asc" | "desc";
+type PinnedDirection = "left" | "right";
+type FilterType = "text" | "number" | "date" | "set";
+type CellAlign = "left" | "center" | "right";
+type TextFilterMatch = "contains" | "notContains" | "equals" | "notEquals" | "startsWith" | "endsWith" | "blank" | "notBlank";
+type NumberFilterMatch = "equals" | "notEquals" | "lessThan" | "lessThanOrEqual" | "greaterThan" | "greaterThanOrEqual" | "inRange" | "blank" | "notBlank";
+type DateFilterMatch = "equals" | "notEquals" | "lessThan" | "greaterThan" | "inRange" | "blank" | "notBlank";
+interface TextFilterCondition {
+    match: TextFilterMatch;
+    value?: string;
+}
+interface NumberFilterCondition {
+    match: NumberFilterMatch;
+    value?: number;
+    value2?: number;
+}
+interface DateFilterCondition {
+    match: DateFilterMatch;
+    value?: string;
+    value2?: string;
+}
+interface SetFilterCondition {
+    values: (string | number | null)[];
+}
+interface TextColumnFilter {
+    type: "text";
+    operator?: "and" | "or";
+    conditions: TextFilterCondition[];
+}
+interface NumberColumnFilter {
+    type: "number";
+    operator?: "and" | "or";
+    conditions: NumberFilterCondition[];
+}
+interface DateColumnFilter {
+    type: "date";
+    operator?: "and" | "or";
+    conditions: DateFilterCondition[];
+}
+interface SetColumnFilter {
+    type: "set";
+    values: (string | number | null)[];
+}
+type ColumnFilter = TextColumnFilter | NumberColumnFilter | DateColumnFilter | SetColumnFilter;
+type FilterModel = Record<string, ColumnFilter>;
+interface SortModelItem {
+    colId: string;
+    direction: SortDirection;
+}
+type SortModel = SortModelItem[];
+interface SelectEditorParams {
+    values: (string | number)[];
+}
+interface SetFilterParams {
+    values?: (string | number | null)[];
+    maxValues?: number;
+}
+type CellEditorFactory = (params: CellEditorParams) => ICellEditor;
+type CellRendererFn = (params: CellRendererParams) => string | HTMLElement | ICellRendererResult | null | undefined;
+type CellClassRule = string | string[] | ((params: CellClassParams) => string | string[] | null | undefined);
+type CellStyleRule = Partial<CSSStyleDeclaration> | ((params: CellClassParams<any, any>) => Partial<CSSStyleDeclaration> | null | undefined);
+interface ColDef<TData = any, TValue = any> {
+    colId?: string;
+    field?: string;
+    headerName?: string;
+    align?: CellAlign;
+    headerAlign?: CellAlign;
+    headerClass?: string | string[];
+    headerTooltip?: string;
+    headerComponent?: (params: HeaderComponentParams<TData>) => string | HTMLElement | ICellRendererResult | null | undefined;
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    flex?: number;
+    hide?: boolean;
+    pinned?: PinnedDirection | boolean;
+    sortable?: boolean;
+    resizable?: boolean;
+    movable?: boolean;
+    filter?: boolean | FilterType;
+    filterParams?: SetFilterParams;
+    editable?: boolean | ((params: EditableParams<TData, TValue>) => boolean);
+    cellEditor?: "text" | "number" | "date" | "select" | CellEditorFactory | string;
+    cellEditorParams?: SelectEditorParams;
+    wrapText?: boolean;
+    checkboxSelection?: boolean;
+    rowGroup?: boolean;
+    aggFunc?: string;
+    cellStyle?: CellStyleRule;
+    selectable?: (params: CellClassParams<TData, TValue>) => boolean;
+    singleClickEdit?: boolean;
+    tooltipValueGetter?: (params: ValueFormatterParams<TData, TValue>) => string | null | undefined;
+    rowSpan?: (params: CellClassParams<TData, TValue>) => number;
+    autoRowSpan?: boolean;
+    colSpan?: (params: CellClassParams<TData, TValue>) => number;
+    autoHeight?: boolean;
+    validate?: (newValue: TValue, params: ValueSetterParams<TData, TValue>) => string | true | null | undefined;
+    rowDrag?: boolean;
+    valueGetter?: (params: ValueGetterParams<TData, TValue>) => TValue;
+    valueSetter?: (params: ValueSetterParams<TData, TValue>) => boolean;
+    valueFormatter?: (params: ValueFormatterParams<TData, TValue>) => any;
+    cellRenderer?: CellRendererFn | string;
+    cellRendererParams?: Record<string, any>;
+    cellClass?: CellClassRule;
+    comparator?: (valueA: any, valueB: any, nodeA: RowNode<TData>, nodeB: RowNode<TData>) => number;
+    type?: string;
+    initialSort?: SortDirection;
+    onCellClick?: (event: CellClickEvent<TData, TValue>) => void;
+    onCellDoubleClick?: (event: CellDoubleClickEvent<TData, TValue>) => void;
+}
+interface ColDefGroup<TData = any> {
+    groupId?: string;
+    headerName?: string;
+    headerClass?: string | string[];
+    children: (ColDefGroup<TData> | ColDef<TData>)[];
+}
+type ColDefOrGroup<TData = any> = ColDefGroup<TData> | ColDef<TData>;
+declare function isColDefGroup<TData = any>(def: ColDefOrGroup<TData>): def is ColDefGroup<TData>;
+interface ColumnState {
+    colId: string;
+    hide?: boolean;
+    width?: number;
+    pinned?: "left" | "right" | null;
+    sort?: SortDirection | null;
+    sortIndex?: number | null;
+}
+
+declare function createGrid<TData = any>(container: HTMLElement, options?: GridOptions<TData>): GridApi<TData>;
+
+type EventKey<TEvents extends object> = Extract<keyof TEvents, string>;
+type Listener<TEvent> = (event: TEvent) => void;
+declare class EventBus<TEvents extends object = Record<string, any>> {
+    private onListenerError?;
+    private listeners;
+    constructor(onListenerError?: ((error: unknown, eventType: EventKey<TEvents>) => void) | undefined);
+    on<K extends EventKey<TEvents>>(type: K, listener: Listener<TEvents[K]>): () => void;
+    once<K extends EventKey<TEvents>>(type: K, listener: Listener<TEvents[K]>): () => void;
+    off<K extends EventKey<TEvents>>(type: K, listener: Listener<TEvents[K]>): void;
+    emit<K extends EventKey<TEvents>>(type: K, payload?: TEvents[K]): void;
+    clear(): void;
+}
+
+type PaneType = "left" | "center" | "right";
+type ColumnModelContext = Pick<GridCore<any>, "options">;
+declare class ColumnModel {
+    private core;
+    private columns;
+    private rootChildren;
+    private left;
+    private center;
+    private right;
+    private sortModel;
+    private defs;
+    private headerDepth;
+    private flatIndexById;
+    viewportWidth: number;
+    constructor(core: ColumnModelContext);
+    setColumnDefs(colDefs: ColDefOrGroup<any>[] | null | undefined): void;
+    private collectLeaves;
+    private regroup;
+    getFlatIndex(colId: string): number;
+    getColumns(): Column[];
+    getColumnDefs(): ColDefOrGroup<any>[];
+    getRootChildren(): (ColumnGroup<any> | Column<any>)[];
+    getHeaderDepth(): number;
+    getColumn(colId: string): Column | undefined;
+    getPaneColumns(pane: PaneType): Column[];
+    getOrderedVisible(): Column[];
+    getRowGroupColumns(): Column[];
+    getAggColumns(): Column[];
+    hasColSpan(): boolean;
+    getGroupLabelColumn(): Column | undefined;
+    paneOf(column: Column): PaneType;
+    computeLayout(viewportWidth: number): void;
+    private widthInputOf;
+    setColumnWidth(column: Column, width: number): void;
+    setColumnVisibility(colId: string, visible: boolean): void;
+    moveColumn(colId: string, toIndex: number): boolean;
+    setColumnPinned(colId: string, pinned: PinnedDirection | null): void;
+    getColumnState(): ColumnState[];
+    applyColumnState(states: ColumnState[]): void;
+    private applyStateOrder;
+    resetColumnState(): void;
+    getSortModel(): SortModel;
+    applySortModel(sortModel: SortModel | null): void;
+    cycleSort(column: Column, additive: boolean): void;
+}
+
+type RowModelContext = Pick<GridCore<any>, "bodyRenderer" | "columnModel" | "emit" | "getApi" | "getCellValue" | "getLocaleText" | "headerRenderer" | "isDestroyed" | "nextId" | "options" | "relayout" | "reportError" | "selectionService" | "skeleton" | "undoService">;
+declare class RowModel<TData = any> {
+    private core;
+    private all;
+    private roots;
+    private childIds;
+    private displayed;
+    private nodesById;
+    private filterModel;
+    private quickFilter;
+    private expandedIds;
+    private groupExpandedIds;
+    private knownGroupIds;
+    private spanInfo;
+    private mastersBuf;
+    private infiniteLastRow;
+    private infiniteRequested;
+    private infiniteLoading;
+    private infiniteSeq;
+    private infiniteAbort;
+    private infinitePendingResolve;
+    private treeDepth;
+    private rowSequence;
+    constructor(core: RowModelContext);
+    resolveRowId(data: TData, index: number, fallback: string): string;
+    get isTree(): boolean;
+    get isInfinite(): boolean;
+    getDisplayTotalCount(): number;
+    isLoadingInfinite(): boolean;
+    startInfinite(): Promise<void>;
+    reloadInfinite(): Promise<void>;
+    private setInfiniteLoading;
+    private loadBlock;
+    private cancelInfiniteRequest;
+    private appendInfiniteRows;
+    checkInfiniteScroll(lastVisibleIndex: number): void;
+    onServerParamsChanged(): Promise<void>;
+    onDatasourceChanged(): Promise<void>;
+    destroy(): void;
+    setRowData(rows: TData[] | null | undefined): void;
+    getChildrenIds(id: string): string[];
+    getChildrenCount(id: string): number;
+    hasChildren(id: string): boolean;
+    applyTransaction(transaction: RowTransaction<TData>): void;
+    private buildChildNodes;
+    private reindexAll;
+    setFilterModel(filterModel: FilterModel | null): boolean;
+    getFilterModel(): FilterModel;
+    setQuickFilter(text: string | null | undefined): boolean;
+    getQuickFilter(): string | null;
+    isFilterPresent(): boolean;
+    refreshPipeline(): void;
+    private pipelineRows;
+    private page;
+    private pageSize;
+    get paginationActive(): boolean;
+    private applyPagination;
+    private effectivePageSize;
+    getCurrentPage(): number;
+    getTotalRowCount(): number;
+    getPageCount(): number;
+    getPipelineRows(): RowNode<TData>[];
+    setPage(page: number, silent?: boolean): void;
+    setPageSize(size: number): void;
+    setPaginationEnabled(enabled: boolean): void;
+    onPaginationOptionsChanged(): void;
+    private emitPaginationChanged;
+    private buildTreeDisplay;
+    private computeSpans;
+    getSpanInfo(colId: string): Int32Array | undefined;
+    getRowSeq(node: RowNode<TData>): number;
+    getTreeDepth(node: RowNode<TData>): number;
+    private buildGrouped;
+    isRowExpandable(node: RowNode<TData>): boolean;
+    isRowExpanded(id: string): boolean;
+    expandRow(id: string): boolean;
+    collapseRow(id: string): boolean;
+    toggleDetail(id: string): boolean;
+    private setDetailExpanded;
+    expandAllDetails(): void;
+    collapseAllDetails(): void;
+    toggleGroup(groupId: string): boolean;
+    isGroupExpanded(groupId: string): boolean;
+    getGroupNode(groupId: string): RowNode<TData> | undefined;
+    expandAllGroups(): void;
+    collapseAllGroups(): void;
+    private setGroupExpanded;
+    reorderRowsByDisplayed(fromIndex: number, toIndex: number): boolean;
+    getAllNodes(): RowNode<TData>[];
+    getRootNodes(): RowNode<TData>[];
+    getDisplayedRows(): RowNode<TData>[];
+    getDisplayedRowCount(): number;
+    getDisplayedRow(index: number): RowNode<TData> | undefined;
+    getNodeById(id: string): RowNode<TData> | undefined;
+    forEachNode(callback: (node: RowNode<TData>, index: number) => void): void;
+    forEachNodeAfterFilterAndSort(callback: (node: RowNode<TData>, index: number) => void): void;
+}
+
+type SelectionContext = Pick<GridCore<any>, "bodyRenderer" | "columnModel" | "emit" | "getApi" | "getCellValue" | "headerRenderer" | "options" | "reportError" | "rowModel">;
+declare class SelectionService {
+    private core;
+    private selectedIds;
+    private anchorId;
+    private indeterminateIds;
+    constructor(core: SelectionContext);
+    isSelected(id: string): boolean;
+    isIndeterminate(id: string): boolean;
+    isSelectable(node: RowNode<any>): boolean;
+    private findSelectableColumn;
+    getSelectedNodes(): RowNode<any>[];
+    getSelectedRows(): any[];
+    getSelectedIds(): string[];
+    onRowsRebuilt(preserveIds: boolean): void;
+    getGroupSelectionState(groupNode: RowNode<any>): {
+        all: boolean;
+        some: boolean;
+    };
+    setGroupSelected(groupNode: RowNode<any>, selected: boolean): void;
+    setNodeSelected(node: RowNode<any>, selected: boolean, clearOthers?: boolean): void;
+    selectNodeById(nodeId: string, selected?: boolean, clearOthers?: boolean): void;
+    onRowClick(node: RowNode<any>, event: MouseEvent, fromCheckbox: boolean): void;
+    selectAll(filteredOnly?: boolean): void;
+    deselectAll(): void;
+    isSelectAllActive(): boolean;
+    isSelectAllIndeterminate(): boolean;
+    applySelectionPublic(changes: {
+        node: RowNode<any>;
+        selected: boolean;
+        clearOthers?: boolean;
+    }[], clearOthers?: boolean): void;
+    private applySelection;
+    private subtreeIds;
+    private recomputeTriState;
+}
+
+type ResizeContext = Pick<GridCore<any>, "columnModel" | "emit" | "persistColumnState" | "relayoutColumns" | "skeleton">;
+declare class ResizeService {
+    private core;
+    private active;
+    private rafId;
+    private pendingWidth;
+    constructor(core: ResizeContext);
+    startResize(e: PointerEvent, column: Column): void;
+    private onMove;
+    private onUp;
+    destroy(): void;
+}
+
+type ColumnDragContext = Pick<GridCore<any>, "bodyRenderer" | "columnModel" | "moveColumn" | "skeleton">;
+declare class ColumnDragService {
+    private core;
+    private pending;
+    private dragging;
+    private suppressClick;
+    constructor(core: ColumnDragContext);
+    onPointerDown(e: PointerEvent, column: Column): void;
+    didDrag(): boolean;
+    private onMove;
+    private startDrag;
+    private findHeaderCell;
+    private updateIndicator;
+    private onUp;
+    private cleanup;
+    destroy(): void;
+}
+
+type KeyboardContext = Pick<GridCore<any>, "bodyRenderer" | "buildRangeTsv" | "clearRangeValues" | "columnModel" | "editingService" | "isDestroyed" | "options" | "pasteText" | "rowModel" | "selectionService" | "skeleton" | "undoService">;
+declare class KeyboardService {
+    private core;
+    constructor(core: KeyboardContext);
+    init(): void;
+    destroy(): void;
+    nextEditable(rowIndex: number, colId: string, dir: 1 | -1): {
+        rowIndex: number;
+        column: Column;
+    } | null;
+    private skipDetailRows;
+    private onCopy;
+    private onCut;
+    private onPaste;
+    private onKeyDown;
+}
+
+type EditingContext = Pick<GridCore<any>, "bodyRenderer" | "emit" | "getApi" | "getCellValue" | "keyboardService" | "reportError" | "resolveCellEditor" | "rowModel" | "setCellValue">;
+declare class EditingService {
+    private core;
+    private editing;
+    constructor(core: EditingContext);
+    isEditing(rowIndex?: number, colId?: string): boolean;
+    isEditable(node: RowNode<any>, column: Column): boolean;
+    start(rowIndex: number, column: Column, keyPress?: string | null): boolean;
+    stop(cancel?: boolean): void;
+    private validateValue;
+    private showError;
+    private applyValue;
+    private onEditorKeyDown;
+    private onEditorBlur;
+    destroy(): void;
+}
+
+type FilterPopupContext = Pick<GridCore<any>, "applyColumnFilter" | "getCellValue" | "getLocaleText" | "rowModel">;
+declare class FilterPopupService {
+    private core;
+    private panel;
+    private openColId;
+    constructor(core: FilterPopupContext);
+    toggle(column: Column, anchor: HTMLElement): void;
+    private docMouseDown;
+    private docKeyDown;
+    private open;
+    close(): void;
+    destroy(): void;
+    private buildConditionBody;
+    private buildSetBody;
+    private readFilter;
+}
+
+type ColumnMenuContext = Pick<GridCore<any>, "columnModel" | "getApi" | "getLocaleText" | "options" | "skeleton">;
+declare class ColumnMenuService {
+    private core;
+    private panel;
+    private openColId;
+    private standaloneAnchor;
+    constructor(core: ColumnMenuContext);
+    toggle(column: Column, anchor: HTMLElement): void;
+    openStandalone(anchor?: HTMLElement): void;
+    close(): void;
+    destroy(): void;
+    private docMouseDown;
+    private docKeyDown;
+    private open;
+    private rebuildListStates;
+}
+
+type ContextMenuContext = Pick<GridCore<any>, "bodyRenderer" | "clearRangeValues" | "columnModel" | "copyActiveRange" | "getApi" | "getCellValue" | "getLocaleText" | "options" | "pasteFromSystemClipboard" | "reportError" | "rowModel">;
+declare class ContextMenuService {
+    private core;
+    private panel;
+    constructor(core: ContextMenuContext);
+    open(x: number, y: number, anchor?: {
+        rowIndex: number;
+        colId: string;
+    }): void;
+    private attach;
+    close(): void;
+    destroy(): void;
+    private docMouseDown;
+    private docKeyDown;
+}
+
+type TooltipContext = Pick<GridCore<any>, "columnModel" | "getApi" | "getCellValue" | "isDestroyed" | "options" | "reportError" | "rowModel" | "skeleton">;
+declare class TooltipService {
+    private core;
+    private panel;
+    private showTimer;
+    private hideTimer;
+    private currentCell;
+    constructor(core: TooltipContext);
+    init(): void;
+    destroy(): void;
+    hide(): void;
+    private clearTimers;
+    private removePanel;
+    private onMouseOver;
+    private onBodyLeave;
+    private showPanel;
+}
+
+type WatermarkContext = Pick<GridCore<any>, "isDestroyed" | "options" | "skeleton">;
+declare class WatermarkService {
+    private core;
+    private overlay;
+    constructor(core: WatermarkContext);
+    init(): void;
+    apply(): void;
+    private buildTile;
+    private isDark;
+    refresh(): void;
+    destroy(): void;
+}
+
+type UndoContext = Pick<GridCore<any>, "bodyRenderer" | "columnModel" | "emit" | "options" | "rowModel" | "statusBarService" | "summaryRenderer" | "writeValue">;
+interface UndoEntry {
+    nodeId: string;
+    columnId: string;
+    oldValue: any;
+    newValue: any;
+}
+declare class UndoRedoService {
+    private core;
+    private stack;
+    private pointer;
+    private pending;
+    constructor(core: UndoContext);
+    beginBatch(): void;
+    endBatch(): void;
+    cancelBatch(): void;
+    record(entry: UndoEntry): void;
+    private push;
+    trimToSize(): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    private apply;
+    clear(): void;
+}
+
+type SkeletonContext = Pick<GridCore<any>, "options" | "relayout" | "reportError">;
+declare class GridSkeleton {
+    private core;
+    root: HTMLElement;
+    headerEl: HTMLElement;
+    bodyEl: HTMLElement;
+    pinnedTopEl: HTMLElement;
+    pinnedBottomEl: HTMLElement;
+    headerRows: Record<PaneType, HTMLElement[]>;
+    headerRowContainers: Record<PaneType, HTMLElement>;
+    bodyViewports: Record<PaneType, HTMLElement>;
+    rowContainers: Record<PaneType, HTMLElement>;
+    private headerPanes;
+    private bodyPanes;
+    private overlayWrapper;
+    private overlayContent;
+    private infiniteLoadingEl;
+    private infiniteLoadingText;
+    private currentOverlay;
+    private currentOverlayContent;
+    private currentOverlayAllowsHtml;
+    private customClassTokens;
+    private resizeObserver;
+    private headerDepth;
+    constructor(core: SkeletonContext);
+    init(container: HTMLElement, options: ResolvedGridOptions): void;
+    setHeaderRowCount(depth: number): void;
+    private applyHeaderHeight;
+    setPaneWidths(left: number, right: number): void;
+    private applyPaneWidth;
+    measureViewportWidth(): number;
+    updateHeights(rowHeight: number, headerHeight: number): void;
+    applySize(size: GridSize): void;
+    private themeUnsub;
+    applyTheme(theme: ThemeMode): void;
+    private systemPrefersDark;
+    setStriped(on: boolean): void;
+    setCellBorders(on: boolean): void;
+    setCustomClass(className: string | null | undefined): void;
+    showOverlay(type: "loading" | "noRows", content: OverlayTemplate, allowUnsafeHtml?: boolean): void;
+    hideOverlay(): void;
+    setInfiniteLoading(active: boolean, text: string): void;
+    destroy(): void;
+}
+
+type HeaderContext = Pick<GridCore<any>, "columnDragService" | "columnMenu" | "columnModel" | "cycleSort" | "emit" | "filterPopup" | "getApi" | "isDestroyed" | "moveColumn" | "options" | "relayoutColumns" | "reportError" | "resizeService" | "rowModel" | "selectionService" | "skeleton">;
+declare class HeaderRenderer {
+    private core;
+    private leafCells;
+    private groupCells;
+    private paneTrees;
+    constructor(core: HeaderContext);
+    build(): void;
+    private createLeafCell;
+    private createGroupCell;
+    applyLayout(): void;
+    private visiblePaneLeaves;
+    private onHeaderKeyDown;
+    refreshSortIndicators(): void;
+    refreshFilterIcons(): void;
+    refreshSelectAllCheckbox(): void;
+    destroy(): void;
+}
+
+interface NormalizedRange {
+    r1: number;
+    c1: number;
+    r2: number;
+    c2: number;
+}
+
+type BodyContext = Pick<GridCore<any>, "buildDefaultEmptyState" | "columnModel" | "contextMenuService" | "editingService" | "emit" | "getApi" | "getCellValue" | "gridId" | "isDestroyed" | "options" | "pinnedRowsRenderer" | "reportError" | "resolveCellRenderer" | "rowModel" | "selectionService" | "setCellValue" | "skeleton" | "summaryRenderer" | "toggleDetail" | "tooltipService" | "undoService">;
+interface FocusedCell {
+    rowIndex: number;
+    colId: string;
+}
+declare class BodyRenderer {
+    private core;
+    private pool;
+    private poolSize;
+    private first;
+    private lastExcl;
+    private rafId;
+    private hoverIndex;
+    private positions;
+    private rangeSelection;
+    private rangeDragging;
+    private colFirst;
+    private colLastExcl;
+    focusedCell: FocusedCell | null;
+    private rowDragController;
+    constructor(core: BodyContext);
+    init(): void;
+    destroy(): void;
+    paneForColumn(column: Column): PaneType;
+    private onScroll;
+    syncScroll(): void;
+    private paneWidths;
+    private positionsBuf;
+    private lastMinRowHeight;
+    private rowHeightCache;
+    private pendingFlash;
+    private measureCanvas;
+    applyContainerSizes(): void;
+    invalidateRowHeight(node: RowNode<any>): void;
+    invalidateAllRowHeights(): void;
+    private collectAutoHeightColumns;
+    private get hasAnyAutoHeight();
+    private measureAutoHeight;
+    queueFlash(rowIndexes: number[], colIds: string[]): void;
+    flushFlash(): void;
+    relayout(): void;
+    private growPool;
+    rebuildPool(): void;
+    applyCellLayout(): void;
+    private computeColWindow;
+    updateRange(force?: boolean): void;
+    private hideSlot;
+    private assignSlot;
+    private renderPaneCells;
+    private resolveColSpan;
+    private applySpanWidth;
+    private renderDetailContent;
+    private cleanupDetail;
+    private renderCell;
+    private treeColumnCache;
+    private getTreeColumn;
+    private renderTreeCell;
+    private getNodeDepth;
+    private resetSpanStyle;
+    private applyCellSpanStyle;
+    private renderGroupCell;
+    refreshRows(indexes: number[]): void;
+    refreshAllCells(): void;
+    onDataChanged(): void;
+    refreshOverlays(): void;
+    getCellElement(rowIndex: number, colId: string): HTMLElement | null;
+    private invalidateRangeCache;
+    normalizedRange(): NormalizedRange | null;
+    getNormalizedRangeOrFocus(): NormalizedRange | null;
+    getRangeSelection(): {
+        row1: number;
+        row2: number;
+        colId1: string;
+        colId2: string;
+    } | null;
+    getPasteStart(): {
+        row: number;
+        colIdx: number;
+    } | null;
+    clearRangeSelection(): void;
+    private refreshRowRange;
+    startRange(row: number, colIdx: number, extend: boolean): void;
+    moveRangeEnd(row: number, colIdx: number): void;
+    private applyRangeClass;
+    private fillHandleEl;
+    private fillDrag;
+    private fillFromPointer;
+    private ensureFillHandle;
+    private updateFillHandle;
+    private onFillHandleDown;
+    private fillTargetRow;
+    private fillTargetCol;
+    private fillDragIndicator;
+    private cancelFillDrag;
+    private onFillMove;
+    private fillHorizontal;
+    private onFillUp;
+    private fillValues;
+    private fillValuesInner;
+    setFocusedCell(rowIndex: number | null, colId: string | null): void;
+    private applyFocusClass;
+    private clearFocusClass;
+    private ensureFocusedCellVisible;
+    scrollToIndex(rowIndex: number, position?: "top" | "bottom" | "middle" | "nearest"): void;
+    private setHoverIndex;
+    private toggleHover;
+    focusGridRoot(): void;
+    private resolveEventTarget;
+    private onBodyClick;
+    private firstCheckboxColId;
+    private onBodyDblClick;
+    private onContextMenu;
+    private onMouseDown;
+    private onWindowMouseUp;
+    private onMouseOver;
+    private onMouseLeave;
+    private onDragHandlePointerDown;
+}
+
+type SummaryContext = Pick<GridCore<any>, "columnModel" | "getCellValue" | "isDestroyed" | "options" | "reportError" | "rowModel" | "skeleton">;
+declare class SummaryRenderer {
+    private core;
+    private footerEl;
+    private rows;
+    private cellsByPane;
+    constructor(core: SummaryContext);
+    init(): void;
+    setVisible(visible: boolean): void;
+    refresh(): void;
+    destroy(): void;
+}
+
+type PaginationContext = Pick<GridCore<any>, "eventBus" | "isDestroyed" | "options" | "rowModel" | "skeleton">;
+declare class PaginationBar {
+    private core;
+    private barEl;
+    private totalEl;
+    private pageEl;
+    private sizeSelect;
+    private firstBtn;
+    private prevBtn;
+    private nextBtn;
+    private lastBtn;
+    private offs;
+    constructor(core: PaginationContext);
+    init(): void;
+    private buildSizeOptions;
+    private t;
+    rebuild(): void;
+    refresh(): void;
+    destroy(): void;
+}
+
+type PinnedRowsContext = Pick<GridCore<any>, "columnModel" | "getApi" | "getCellValue" | "isDestroyed" | "options" | "relayout" | "reportError" | "resolveCellRenderer" | "skeleton">;
+declare class PinnedRowsRenderer {
+    private core;
+    private top;
+    private bottom;
+    constructor(core: PinnedRowsContext);
+    init(): void;
+    private createSide;
+    setData(top: any[] | null, bottom: any[] | null): void;
+    setTopData(rows: any[] | null): void;
+    setBottomData(rows: any[] | null): void;
+    getTopData(): any[];
+    getBottomData(): any[];
+    rebuild(): void;
+    private rebuildSide;
+    applyLayout(): void;
+    onScrollLeft(scrollLeft: number): void;
+    refresh(): void;
+    destroy(): void;
+}
+
+type StatusBarContext = Pick<GridCore<any>, "bodyRenderer" | "columnModel" | "eventBus" | "getCellValue" | "isDestroyed" | "options" | "rowModel" | "selectionService" | "skeleton">;
+declare class StatusBarService {
+    private core;
+    private barEl;
+    private items;
+    private offs;
+    constructor(core: StatusBarContext);
+    init(): void;
+    rebuild(): void;
+    refresh(): void;
+    destroy(): void;
+}
+
+declare class GridCore<TData = any> {
+    readonly gridId: number;
+    readonly options: ResolvedGridOptions<TData>;
+    readonly eventBus: EventBus<GridEventMap<TData>>;
+    readonly skeleton: GridSkeleton;
+    readonly columnModel: ColumnModel;
+    readonly rowModel: RowModel<TData>;
+    readonly selectionService: SelectionService;
+    readonly headerRenderer: HeaderRenderer;
+    readonly bodyRenderer: BodyRenderer;
+    readonly resizeService: ResizeService;
+    readonly columnDragService: ColumnDragService;
+    readonly keyboardService: KeyboardService;
+    readonly editingService: EditingService;
+    readonly undoService: UndoRedoService;
+    readonly filterPopup: FilterPopupService;
+    readonly columnMenu: ColumnMenuService;
+    readonly contextMenuService: ContextMenuService;
+    readonly tooltipService: TooltipService;
+    readonly watermarkService: WatermarkService;
+    readonly paginationBar: PaginationBar;
+    readonly pinnedRowsRenderer: PinnedRowsRenderer;
+    readonly summaryRenderer: SummaryRenderer;
+    readonly statusBarService: StatusBarService;
+    readonly api: GridApi<TData>;
+    private destroyed;
+    private autoIdCounter;
+    private readyRafId;
+    private lastColumnLayoutSignature;
+    private activeFeatures;
+    constructor(container: HTMLElement, options: GridOptions<TData>);
+    getApi(): GridApi<TData>;
+    resolveCellRenderer(name: string): CellRendererFn | undefined;
+    resolveCellEditor(name: string): CellEditorFactory | undefined;
+    setFeatures(features: readonly GridFeature<TData>[] | null | undefined): void;
+    private destroyFeatures;
+    isDestroyed(): boolean;
+    nextId(): number;
+    getCellValue(node: RowNode<any>, column: Column): any;
+    getLocaleText(key: RgLocaleKey): string;
+    writeValue(node: RowNode<any>, column: Column, newValue: any, oldValue?: any): boolean;
+    setCellValue(node: RowNode<any>, column: Column, newValue: any, oldValue: any): boolean;
+    buildRangeTsv(range: {
+        r1: number;
+        c1: number;
+        r2: number;
+        c2: number;
+    }): string;
+    copyActiveRange(): Promise<boolean>;
+    clearRangeValues(range: {
+        r1: number;
+        c1: number;
+        r2: number;
+        c2: number;
+    }): void;
+    pasteText(text: string, startRow: number, startColIdx: number): void;
+    pasteFromSystemClipboard(): Promise<void>;
+    refreshSummary(): void;
+    emit<K extends GridEventType>(type: K, extra?: Partial<GridEventMap<TData>[K]>): GridEventMap<TData>[K];
+    reportError(error: unknown, source: string, context?: Record<string, unknown>): void;
+    cycleSort(column: Column, additive: boolean): void;
+    applySortModel(): void;
+    applyColumnFilter(column: Column, filter: ColumnFilter | null): void;
+    applyQuickFilter(): void;
+    moveColumn(colId: string, toIndex: number): void;
+    toggleDetail(rowId: string): boolean;
+    private stateLoadToken;
+    loadPersistedColumnState(): void;
+    persistColumnState(): void;
+    buildDefaultEmptyState(): HTMLElement;
+    private lastValidatedDefs;
+    private issuedWarningSignatures;
+    checkWarnings(): void;
+    validateDefs(defs: (ColDef<any> | ColDefGroup<any>)[] | null | undefined): void;
+    onColumnsStructureChanged(): void;
+    relayout(): void;
+    relayoutColumns(invalidateRowHeights?: boolean): void;
+    destroy(): void;
+}
+
+declare function defaultComparator(valueA: any, valueB: any): number;
+
+declare function isSafePath(path: string): boolean;
+declare function getByPath(obj: any, path: string): any;
+declare function setByPath(obj: any, path: string, value: any): boolean;
+
+interface WidthInput {
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    flex?: number;
+}
+declare function computeColumnWidths(cols: WidthInput[], availableWidth: number): number[];
+
+interface GridSizePreset {
+    rowHeight: number;
+    headerHeight: number;
+    fontSize: number;
+    cellPadding: number;
+}
+declare const GRID_SIZE_PRESETS: Record<GridSize, GridSizePreset>;
+
+type GridOptionValueKind = "array" | "boolean" | "boolean-object" | "function" | "number" | "object" | "string" | "unknown";
+type GridOptionUpdateMode = "columnDefs" | "options" | "quickFilter" | "rowData";
+interface GridOptionMetadata {
+    /** Runtime value category used by framework adapters. */
+    kind: GridOptionValueKind;
+    /** How a changed framework prop is forwarded to GridApi. */
+    update: GridOptionUpdateMode;
+}
+type EventOptionKey = `on${Capitalize<GridEventType>}`;
+type GridOptionKey = Exclude<keyof GridOptions<any>, EventOptionKey>;
+/**
+ * Runtime single source of truth for every non-event GridOptions property.
+ *
+ * The mapped `satisfies` type intentionally makes adding a GridOptions field a
+ * compile error until its adapter/update behavior is declared here.
+ */
+declare const GRID_OPTION_META: {
+    readonly columnDefs: {
+        readonly kind: "array";
+        readonly update: "columnDefs";
+    };
+    readonly rowData: {
+        readonly kind: "array";
+        readonly update: "rowData";
+    };
+    readonly defaultColDef: {
+        readonly kind: "object";
+        readonly update: "options";
+    };
+    readonly getRowId: {
+        readonly kind: "function";
+        readonly update: "options";
+    };
+    readonly rowHeight: {
+        readonly kind: "number";
+        readonly update: "options";
+    };
+    readonly headerHeight: {
+        readonly kind: "number";
+        readonly update: "options";
+    };
+    readonly rowBuffer: {
+        readonly kind: "number";
+        readonly update: "options";
+    };
+    readonly rowSelection: {
+        readonly kind: "string";
+        readonly update: "options";
+    };
+    readonly multiSort: {
+        readonly kind: "boolean";
+        readonly update: "options";
+    };
+    readonly size: {
+        readonly kind: "string";
+        readonly update: "options";
+    };
+    readonly stripedRows: {
+        readonly kind: "boolean";
+        readonly update: "options";
+    };
+    readonly showCellBorders: {
+        readonly kind: "boolean";
+        readonly update: "options";
+    };
+    readonly theme: {
+        readonly kind: "string";
+        readonly update: "options";
+    };
+    readonly quickFilterText: {
+        readonly kind: "string";
+        readonly update: "quickFilter";
+    };
+    readonly masterDetail: {
+        readonly kind: "boolean";
+        readonly update: "options";
+    };
+    readonly detailRowHeight: {
+        readonly kind: "number";
+        readonly update: "options";
+    };
+    readonly detailRowRenderer: {
+        readonly kind: "function";
+        readonly update: "options";
+    };
+    readonly isRowExpandable: {
+        readonly kind: "function";
+        readonly update: "options";
+    };
+    readonly detailToggleColumn: {
+        readonly kind: "boolean";
+        readonly update: "options";
+    };
+    readonly columnMenu: {
+        readonly kind: "boolean";
+        readonly update: "options";
+    };
+    readonly columnStateKey: {
+        readonly kind: "string";
+        readonly update: "options";
+    };
+    readonly columnStateStore: {
+        readonly kind: "object";
+        readonly update: "options";
+    };
+    readonly aggFuncs: {
+        readonly kind: "object";
+        readonly update: "options";
+    };
+    readonly components: {
+        readonly kind: "object";
+        readonly update: "options";
+    };
+    readonly features: {
+        readonly kind: "array";
+        readonly update: "options";
+    };
+    readonly locale: {
+        readonly kind: "object";
+        readonly update: "options";
+    };
+    readonly singleClickEdit: {
+        readonly kind: "boolean";
+        readonly update: "options";
+    };
+    readonly manualSorting: {
+        readonly kind: "boolean";
+        readonly update: "options";
+    };
+    readonly manualFiltering: {
+        readonly kind: "boolean";
+        readonly update: "options";
+    };
+    readonly showSummary: {
+        readonly kind: "boolean";
+        readonly update: "options";
+    };
+    readonly summaryMethod: {
+        readonly kind: "function";
+        readonly update: "options";
+    };
+    readonly treeData: {
+        readonly kind: "boolean";
+        readonly update: "options";
+    };
+    readonly childrenKey: {
+        readonly kind: "string";
+        readonly update: "options";
+    };
+    readonly autoCheckedChildren: {
+        readonly kind: "boolean";
+        readonly update: "options";
+    };
+    readonly defaultExpandAll: {
+        readonly kind: "boolean";
+        readonly update: "options";
+    };
+    readonly indexOffset: {
+        readonly kind: "number";
+        readonly update: "options";
+    };
+    readonly applyRowDrag: {
+        readonly kind: "boolean";
+        readonly update: "options";
+    };
+    readonly undoStackSize: {
+        readonly kind: "number";
+        readonly update: "options";
+    };
+    readonly getRowHeight: {
+        readonly kind: "function";
+        readonly update: "options";
+    };
+    readonly pinnedTopRowData: {
+        readonly kind: "array";
+        readonly update: "options";
+    };
+    readonly pinnedBottomRowData: {
+        readonly kind: "array";
+        readonly update: "options";
+    };
+    readonly pagination: {
+        readonly kind: "boolean-object";
+        readonly update: "options";
+    };
+    readonly watermark: {
+        readonly kind: "boolean-object";
+        readonly update: "options";
+    };
+    readonly suppressWarnings: {
+        readonly kind: "boolean";
+        readonly update: "options";
+    };
+    readonly enableRangeSelection: {
+        readonly kind: "boolean";
+        readonly update: "options";
+    };
+    readonly suppressClipboard: {
+        readonly kind: "boolean";
+        readonly update: "options";
+    };
+    readonly contextMenu: {
+        readonly kind: "boolean";
+        readonly update: "options";
+    };
+    readonly getContextMenuItems: {
+        readonly kind: "function";
+        readonly update: "options";
+    };
+    readonly tooltipComponent: {
+        readonly kind: "function";
+        readonly update: "options";
+    };
+    readonly tooltipShowDelay: {
+        readonly kind: "number";
+        readonly update: "options";
+    };
+    readonly flashCells: {
+        readonly kind: "boolean";
+        readonly update: "options";
+    };
+    readonly fillHandle: {
+        readonly kind: "boolean";
+        readonly update: "options";
+    };
+    readonly statusBar: {
+        readonly kind: "boolean-object";
+        readonly update: "options";
+    };
+    readonly datasource: {
+        readonly kind: "object";
+        readonly update: "options";
+    };
+    readonly blockSize: {
+        readonly kind: "number";
+        readonly update: "options";
+    };
+    readonly infiniteBufferRows: {
+        readonly kind: "number";
+        readonly update: "options";
+    };
+    readonly suppressCellFocus: {
+        readonly kind: "boolean";
+        readonly update: "options";
+    };
+    readonly suppressRowHoverHighlight: {
+        readonly kind: "boolean";
+        readonly update: "options";
+    };
+    readonly suppressNoRowsOverlay: {
+        readonly kind: "boolean";
+        readonly update: "options";
+    };
+    readonly suppressHeaderFocus: {
+        readonly kind: "boolean";
+        readonly update: "options";
+    };
+    readonly loading: {
+        readonly kind: "boolean";
+        readonly update: "options";
+    };
+    readonly overlayNoRowsTemplate: {
+        readonly kind: "unknown";
+        readonly update: "options";
+    };
+    readonly overlayLoadingTemplate: {
+        readonly kind: "unknown";
+        readonly update: "options";
+    };
+    readonly allowUnsafeOverlayHtml: {
+        readonly kind: "boolean";
+        readonly update: "options";
+    };
+    readonly className: {
+        readonly kind: "string";
+        readonly update: "options";
+    };
+};
+declare const GRID_OPTION_KEYS: readonly GridOptionKey[];
+declare const DIRECT_GRID_OPTION_KEYS: readonly GridOptionKey[];
+
+declare function describeFilter(filter: ColumnFilter): string;
+
+type GridSchemaFieldType = "string" | "number" | "date" | "select" | "boolean";
+interface SchemaSelectOption {
+    label: string;
+    value: string | number;
+}
+interface GridSchemaField {
+    field: string;
+    title?: string;
+    type?: GridSchemaFieldType;
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    flex?: number;
+    pinned?: "left" | "right";
+    editable?: boolean;
+    sortable?: boolean;
+    filterable?: boolean;
+    resizable?: boolean;
+    hidden?: boolean;
+    options?: SchemaSelectOption[];
+    format?: "date" | "datetime";
+    cellClass?: string | string[];
+}
+interface GridSchemaGroup {
+    title: string;
+    fields: string[];
+}
+interface GridSchema {
+    fields: GridSchemaField[];
+    groups?: GridSchemaGroup[];
+}
+declare function buildColDefsFromSchema<TData = any>(schema: GridSchema): (ColDef<TData> | ColDefGroup<TData>)[];
+
+declare function saveColumnState(key: string, state: ColumnState[]): void;
+declare function loadColumnState(key: string): ColumnState[] | null;
+declare function clearColumnState(key: string): void;
+
+type AggValues = Record<string, any>;
+type AggFunction = (values: any[]) => any;
+declare const BUILTIN_AGG_FUNCS: Record<string, AggFunction>;
+declare function createAggResolver(custom?: Record<string, AggFunction>): (name: string) => AggFunction | undefined;
+
+declare function toTsv(rows: any[][], protectFormulas?: boolean): string;
+declare function parseTsv(text: string): string[][];
+declare function parseCsv(text: string, separator?: string): string[][];
+declare function parseDelimited(text: string, separator: string): string[][];
+
+declare function escapeHtml(value: any): string;
+declare function downloadFile(filename: string, content: string, mime?: string): boolean;
+
+declare function sanitizeFormulaCell(value: any): any;
+
+declare function registerCellRenderer(name: string, renderer: CellRendererFn): () => void;
+declare function getCellRenderer(name: string): CellRendererFn | undefined;
+declare function registerCellEditor(name: string, editor: CellEditorFactory): () => void;
+declare function getCellEditor(name: string): CellEditorFactory | undefined;
+declare function clearComponentRegistries(): void;
+
+type TagVariant = "success" | "warning" | "danger" | "info" | "neutral";
+interface StatusTagConfig {
+    variantMap?: Record<string, TagVariant>;
+    labelMap?: Record<string, string>;
+}
+declare function resolveTagVariant(value: any, variantMap?: Record<string, TagVariant>): TagVariant;
+declare function createStatusTagRenderer(config?: StatusTagConfig): CellRendererFn;
+interface ProgressConfig {
+    showValue?: boolean;
+    unit?: string;
+    color?: string;
+}
+declare function createProgressBarRenderer(config?: ProgressConfig): CellRendererFn;
+declare function linkRenderer(params: CellRendererParams): string | HTMLElement;
+interface ActionItem<TData = any> {
+    icon?: string;
+    label?: string;
+    title?: string;
+    danger?: boolean;
+    show?: (params: CellRendererParams<TData>) => boolean;
+    onClick: (params: CellRendererParams<TData>) => void;
+}
+interface ActionButtonsConfig {
+    actions: ActionItem[];
+    max?: number;
+}
+declare function createActionButtonsRenderer(config: ActionButtonsConfig): CellRendererFn;
+declare function registerBuiltinRenderers(register: (name: string, fn: CellRendererFn) => void): void;
+
+declare function selectionColumn<TData = any>(overrides?: Partial<ColDef<TData>>): ColDef<TData>;
+declare function indexColumn<TData = any>(overrides?: Partial<ColDef<TData>>): ColDef<TData>;
+declare function dragColumn<TData = any>(overrides?: Partial<ColDef<TData>>): ColDef<TData>;
+declare function actionsColumn<TData = any>(config?: ActionButtonsConfig & {
+    width?: number;
+    pinned?: "left" | "right";
+}): ColDef<TData>;
+
+declare function evaluateColumnFilter(value: any, filter: ColumnFilter): boolean;
+
+declare function sortNodes<TData>(nodes: RowNode<TData>[], sortModel: SortModel, columns: Column[], getCellValue: (node: RowNode<TData>, column: Column) => any): RowNode<TData>[];
+
+declare const version: string;
+
+export { type ActionButtonsConfig, type ActionItem, type AggFunction, type AggValues, BUILTIN_AGG_FUNCS, type CellAlign, type CellClassParams, type CellClassRule, type CellClickEvent, type CellContextMenuEvent, type CellDoubleClickEvent, type CellEditingStartedEvent, type CellEditingStoppedEvent, type CellEditorFactory, type CellEditorParams, type CellRendererFn, type CellRendererOutput, type CellRendererParams, type CellStyleRule, type CellValueChangedEvent, type ColDef, type ColDefGroup, type ColDefOrGroup, Column, type ColumnFilter, type ColumnMovedEvent, type ColumnResizedEvent, type ColumnState, type ColumnStateStore, type ColumnVisibilityChangedEvent, type ContextMenuItem, type ContextMenuParams, type CsvExportParams, DEFAULT_LOCALE, DIRECT_GRID_OPTION_KEYS, type DateFilterCondition, type DateFilterMatch, type DetailRowRendererParams, type DetailToggledEvent, EVENT_TYPES, type EditableParams, EventBus, type EventHandlers, type FilterChangedEvent, type FilterModel, type FilterType, GRID_OPTION_KEYS, GRID_OPTION_META, GRID_SIZE_PRESETS, type GetRowHeightParams, type GetRowIdParams, type GridApi, type GridCellRange, type GridComponents, GridCore, type GridDatasource, type GridErrorEvent, type GridEventBase, type GridEventMap, type GridEventType, type GridFeature, type GridFeatureContext, type GridOptionKey, type GridOptionMetadata, type GridOptionUpdateMode, type GridOptionValueKind, type GridOptions, type GridReadyEvent, type GridSchema, type GridSchemaField, type GridSchemaFieldType, type GridSchemaGroup, type GridSize, type GridSizePreset, type HeaderComponentParams, type ICellEditor, type ICellRendererResult, type ImportCsvOptions, type InfiniteGetRowsParams, LOCALE_EN, type ModelUpdatedEvent, type NumberFilterCondition, type NumberFilterMatch, type OverlayTemplate, type PaginationChangedEvent, type PaginationConfig, type PinnedDirection, type PrintOptions, type ProgressConfig, type RangeSelectionChangedEvent, type ResolvedGridOptions, type RgLocale, type RgLocaleKey, type RowClickEvent, type RowDragEndEvent, type RowNode, type RowSelectionMode, type RowTransaction, type SchemaSelectOption, type SelectEditorParams, type SelectionChangedEvent, type SetFilterCondition, type SetFilterParams, type SortChangedEvent, type SortDirection, type SortModel, type SortModelItem, type StatusBarConfig, type StatusBarPanel, type StatusTagConfig, type TagVariant, type TextFilterCondition, type TextFilterMatch, type ThemeMode, type TooltipParams, type ValueFormatterParams, type ValueGetterParams, type ValueSetterParams, type WatermarkConfig, type WidthInput, actionsColumn, buildColDefsFromSchema, clearColumnState, clearComponentRegistries, computeColumnWidths, createActionButtonsRenderer, createAggResolver, createGrid, createProgressBarRenderer, createStatusTagRenderer, defaultComparator, describeFilter, downloadFile, dragColumn, escapeHtml, evaluateColumnFilter, formatText, formatTwo, getByPath, getCellEditor, getCellRenderer, indexColumn, isColDefGroup, isSafePath, linkRenderer, loadColumnState, matchLocaleKey, parseCsv, parseDelimited, parseTsv, registerBuiltinRenderers, registerCellEditor, registerCellRenderer, resolveTagVariant, sanitizeFormulaCell, saveColumnState, selectionColumn, setByPath, sortNodes, toTsv, version };