@gp-grid/core 0.22.0 → 0.23.1

package/dist/index.d.ts

@@ -331,8 +331,6 @@ interface TextFilterCondition {
   selectedValues?: Set<CellValue>;
   /** Include blank values */
   includeBlank?: boolean;
-  /** Operator connecting this condition to the next. Defaults to ColumnFilterModel.combination */
-  nextOperator?: FilterCombination;
 }
 /** Number filter condition */
 interface NumberFilterCondition {
@@ -341,8 +339,6 @@ interface NumberFilterCondition {
   value?: number;
   /** Second value for "between" operator */
   valueTo?: number;
-  /** Operator connecting this condition to the next. Defaults to ColumnFilterModel.combination */
-  nextOperator?: FilterCombination;
 }
 /** Date filter condition */
 interface DateFilterCondition {
@@ -351,16 +347,34 @@ interface DateFilterCondition {
   value?: Date | string;
   /** Second value for "between" operator */
   valueTo?: Date | string;
-  /** Operator connecting this condition to the next. Defaults to ColumnFilterModel.combination */
-  nextOperator?: FilterCombination;
 }
 /** Union of filter condition types */
 type FilterCondition = TextFilterCondition | NumberFilterCondition | DateFilterCondition;
-/** Column filter model with multiple conditions */
-interface ColumnFilterModel {
+/** A visibly grouped set of conditions joined by one operator. */
+interface FilterConditionGroup {
   conditions: FilterCondition[];
   combination: FilterCombination;
 }
+/** Column filter model with one explicit level of condition groups. */
+interface ColumnFilterModel {
+  groups: FilterConditionGroup[];
+  combination: FilterCombination;
+}
+/**
+ * Condition shape accepted when restoring a filter created before grouped
+ * composition was introduced.
+ */
+type LegacyFilterCondition = FilterCondition & {
+  /** Operator connecting this condition to the next. */
+  nextOperator?: FilterCombination;
+};
+/** Legacy left-to-right column filter model accepted as migration input. */
+interface LegacyColumnFilterModel {
+  conditions: LegacyFilterCondition[];
+  combination: FilterCombination;
+}
+/** Canonical or legacy input accepted by the imperative filter API. */
+type ColumnFilterInput = ColumnFilterModel | LegacyColumnFilterModel;
 /** Filter model type - maps column ID to filter */
 type FilterModel = Record<string, ColumnFilterModel>;
 //#endregion
@@ -577,102 +591,11 @@ interface DataErrorInstruction {
   type: "DATA_ERROR";
   error: string;
 }
-/** Rows added instruction */
-interface RowsAddedInstruction {
-  type: "ROWS_ADDED";
-  indices: number[];
-  count: number;
-  totalRows: number;
-}
-/** Rows removed instruction */
-interface RowsRemovedInstruction {
-  type: "ROWS_REMOVED";
-  indices: number[];
-  totalRows: number;
-}
-/** Rows updated instruction */
-interface RowsUpdatedInstruction {
-  type: "ROWS_UPDATED";
-  indices: number[];
-}
-/** Transaction processed instruction */
-interface TransactionProcessedInstruction {
-  type: "TRANSACTION_PROCESSED";
-  added: number;
-  removed: number;
-  updated: number;
-}
 /** Columns changed (after resize, reorder, etc.) */
 interface ColumnsChangedInstruction {
   type: "COLUMNS_CHANGED";
   columns: ColumnDefinition[];
 }
-/** Column resize started */
-interface StartColumnResizeInstruction {
-  type: "START_COLUMN_RESIZE";
-  colIndex: number;
-  initialWidth: number;
-}
-/** Column resize in progress */
-interface UpdateColumnResizeInstruction {
-  type: "UPDATE_COLUMN_RESIZE";
-  colIndex: number;
-  currentWidth: number;
-}
-/** Column resize committed */
-interface CommitColumnResizeInstruction {
-  type: "COMMIT_COLUMN_RESIZE";
-  colIndex: number;
-  newWidth: number;
-}
-/** Column resize cancelled */
-interface CancelColumnResizeInstruction {
-  type: "CANCEL_COLUMN_RESIZE";
-}
-/** Column move started */
-interface StartColumnMoveInstruction {
-  type: "START_COLUMN_MOVE";
-  sourceColIndex: number;
-}
-/** Column move position updated */
-interface UpdateColumnMoveInstruction {
-  type: "UPDATE_COLUMN_MOVE";
-  currentX: number;
-  currentY: number;
-  dropTargetIndex: number | null;
-}
-/** Column move committed */
-interface CommitColumnMoveInstruction {
-  type: "COMMIT_COLUMN_MOVE";
-  sourceColIndex: number;
-  targetColIndex: number;
-}
-/** Column move cancelled */
-interface CancelColumnMoveInstruction {
-  type: "CANCEL_COLUMN_MOVE";
-}
-/** Row drag started */
-interface StartRowDragInstruction {
-  type: "START_ROW_DRAG";
-  sourceRowIndex: number;
-}
-/** Row drag position updated */
-interface UpdateRowDragInstruction {
-  type: "UPDATE_ROW_DRAG";
-  currentX: number;
-  currentY: number;
-  dropTargetIndex: number | null;
-}
-/** Row drag committed */
-interface CommitRowDragInstruction {
-  type: "COMMIT_ROW_DRAG";
-  sourceRowIndex: number;
-  targetRowIndex: number;
-}
-/** Row drag cancelled */
-interface CancelRowDragInstruction {
-  type: "CANCEL_ROW_DRAG";
-}
 /** Union type of all instructions */
 type GridInstruction =
 /** Slot lifecycle */
@@ -695,16 +618,8 @@ OpenFilterPopupInstruction | CloseFilterPopupInstruction |
 StartFillInstruction | UpdateFillInstruction | CommitFillInstruction | CancelFillInstruction |
 /** Data */
 DataLoadingInstruction | DataLoadedInstruction | DataErrorInstruction |
-/** Transactions */
-RowsAddedInstruction | RowsRemovedInstruction | RowsUpdatedInstruction | TransactionProcessedInstruction |
 /** Column changes */
-ColumnsChangedInstruction |
-/** Column resize */
-StartColumnResizeInstruction | UpdateColumnResizeInstruction | CommitColumnResizeInstruction | CancelColumnResizeInstruction |
-/** Column move */
-StartColumnMoveInstruction | UpdateColumnMoveInstruction | CommitColumnMoveInstruction | CancelColumnMoveInstruction |
-/** Row drag */
-StartRowDragInstruction | UpdateRowDragInstruction | CommitRowDragInstruction | CancelRowDragInstruction;
+ColumnsChangedInstruction;
 /** Instruction listener: Single instruction Listener that receives a single instruction, used by frameworks to update their state */
 type InstructionListener = (instruction: GridInstruction) => void;
 /** Batch instruction listener: Batch instruction Listener that receives an array of instructions, used by frameworks to update their state */
@@ -757,8 +672,6 @@ interface GridCoreOptions<TData = unknown> {
   rowLoading?: RowLoadingOptions;
   /** Enable/disable sorting globally. Default: true */
   sortingEnabled?: boolean;
-  /** Debounce time for transactions in ms. Default 50. Set to 0 for sync. */
-  transactionDebounceMs?: number;
   /** Function to extract unique ID from row. Required for mutations. */
   getRowId?: (row: TData) => RowId;
   /** Row/column/cell highlighting configuration */
@@ -1079,17 +992,11 @@ declare class ColumnResizeDrag<TData = unknown> {
 //#endregion
 //#region src/input/column-move-drag.d.ts
 declare class ColumnMoveDrag<TData = unknown> {
-  private active;
+  private readonly gesture;
   private sourceColIndex;
-  private startX;
-  private startY;
-  private thresholdMet;
   private shiftKey;
   private ghostWidth;
   private ghostHeight;
-  private currentX;
-  private currentY;
-  private dropTargetIndex;
   private readonly core;
   private deps;
   constructor(core: GridCore<TData>, deps: InputHandlerDeps);
@@ -1107,14 +1014,8 @@ declare class ColumnMoveDrag<TData = unknown> {
 //#endregion
 //#region src/input/row-drag.d.ts
 declare class RowDrag<TData = unknown> {
-  private active;
+  private readonly gesture;
   private sourceRowIndex;
-  private startX;
-  private startY;
-  private thresholdMet;
-  private currentX;
-  private currentY;
-  private dropTargetIndex;
   private readonly core;
   private deps;
   constructor(core: GridCore<TData>, deps: InputHandlerDeps);
@@ -1300,199 +1201,6 @@ declare class HighlightManager<TData = Record<string, unknown>> {
   destroy(): void;
 }
 //#endregion
-//#region src/managers/row-mutation-manager.d.ts
-interface RowMutationManagerOptions<TData> {
-  /** Get the cached rows map */
-  getCachedRows: () => Map<number, TData>;
-  /** Set the cached rows map (for bulk operations) */
-  setCachedRows: (rows: Map<number, TData>) => void;
-  /** Get total row count */
-  getTotalRows: () => number;
-  /** Set total row count */
-  setTotalRows: (count: number) => void;
-  /** Update a single slot after row change */
-  updateSlot: (rowIndex: number) => void;
-  /** Refresh all slots after bulk changes */
-  refreshAllSlots: () => void;
-  /** Emit content size change */
-  emitContentSize: () => void;
-  /** Clear selection if it references invalid rows */
-  clearSelectionIfInvalid: (maxValidRow: number) => void;
-}
-/**
- * Manages row CRUD operations and cache management.
- */
-declare class RowMutationManager<TData = unknown> {
-  private readonly options;
-  private readonly emitter;
-  onInstruction: (listener: InstructionListener) => () => void;
-  private readonly emit;
-  constructor(options: RowMutationManagerOptions<TData>);
-  /**
-   * Get a row by index.
-   */
-  getRow(index: number): TData | undefined;
-  /**
-   * Add rows to the grid at the specified index.
-   * If no index is provided, rows are added at the end.
-   */
-  addRows(rows: TData[], index?: number): void;
-  /**
-   * Update existing rows with partial data.
-   */
-  updateRows(updates: Array<{
-    index: number;
-    data: Partial<TData>;
-  }>): void;
-  /**
-   * Delete rows at the specified indices.
-   */
-  deleteRows(indices: number[]): void;
-  /**
-   * Set a complete row at the specified index.
-   * Use this for complete row replacement. For partial updates, use updateRows.
-   */
-  setRow(index: number, data: TData): void;
-  destroy(): void;
-}
-//#endregion
-//#region src/managers/instruction-batcher.d.ts
-declare class InstructionBatcher {
-  private listeners;
-  private buffer;
-  /**
-   * Subscribe to batched instructions. Returns an unsubscribe function.
-   * Batch listeners receive arrays of instructions instead of individual ones.
-   */
-  subscribe(listener: BatchInstructionListener): () => void;
-  /**
-   * Begin buffering. `emit`/`emitBatch` accumulate into an internal buffer
-   * until `flush()` is called. Supports nested semantics at the caller's
-   * level (first startBatch "wins"; nested calls are no-ops by design).
-   */
-  start(): void;
-  /** Flush buffered instructions to listeners as one batch and stop buffering. */
-  flush(): void;
-  emit(instruction: GridInstruction): void;
-  emitBatch(instructions: GridInstruction[]): void;
-  clearListeners(): void;
-  private notify;
-}
-//#endregion
-//#region src/managers/row-data-manager.d.ts
-interface RowDataManagerOptions<TData> {
-  dataSource: DataSource<TData>;
-  rowLoading: RowLoadingOptions | undefined;
-  batcher: InstructionBatcher;
-  getColumns: () => ColumnDefinition[];
-  getSortModel: () => SortModel[];
-  getFilterModel: () => FilterModel;
-  getRowHeight: () => number;
-  getOverscan: () => number;
-  getScrollTop: () => number;
-  getViewportHeight: () => number;
-  onCellValueChanged?: (event: CellValueChangedEvent<TData>) => void;
-  getRowId?: (row: TData) => RowId;
-  syncSlots: () => void;
-  emitVisibleRange: () => void;
-  emitContentSize: () => void;
-}
-declare class RowDataManager<TData = unknown> {
-  private dataSource;
-  private readonly options;
-  private readonly rowLoading;
-  private readonly rowWindowLoader;
-  private cachedRows;
-  private totalRows;
-  private isDataLoading;
-  constructor(options: RowDataManagerOptions<TData>);
-  getCachedRows(): Map<number, TData>;
-  setCachedRows(rows: Map<number, TData>): void;
-  getTotalRows(): number;
-  setTotalRows(count: number): void;
-  getDataSource(): DataSource<TData>;
-  getRowData(rowIndex: number): TData | undefined;
-  isLoading(): boolean;
-  getCellValue(row: number, col: number): CellValue;
-  setCellValue(row: number, col: number, value: CellValue): void;
-  loadInitial(): Promise<void>;
-  requestVisibleRows(): void;
-  refreshFromTransaction(): Promise<void>;
-  setDataSource(dataSource: DataSource<TData>): void;
-  destroy(): void;
-  private fetchAllData;
-  private fetchPaginatedData;
-  private emitDataError;
-  private isPaginatedLoading;
-  private getInitialPaginatedRange;
-  private getPaginatedLoadRange;
-}
-//#endregion
-//#region src/managers/scroll-virtualization-manager.d.ts
-interface ScrollVirtualizationManagerOptions {
-  getRowHeight: () => number;
-  getHeaderHeight: () => number;
-  getTotalRows: () => number;
-  getScrollTop: () => number;
-  getViewportHeight: () => number;
-}
-declare class ScrollVirtualizationManager {
-  private naturalContentHeight;
-  private virtualContentHeight;
-  private scrollRatio;
-  private readonly options;
-  constructor(options: ScrollVirtualizationManagerOptions);
-  /**
-   * Update scroll virtualization state based on current row count.
-   * Should be called whenever totalRows changes.
-   */
-  updateContentSize(): {
-    naturalHeight: number;
-    virtualHeight: number;
-    scrollRatio: number;
-  };
-  /**
-   * Check if scroll scaling is active (large datasets exceeding browser scroll limits).
-   * When scaling is active, scrollRatio < 1 and scroll positions are compressed.
-   */
-  isScalingActive(): boolean;
-  /**
-   * Get the natural (uncapped) content height.
-   * Useful for debugging or displaying actual content size.
-   */
-  getNaturalHeight(): number;
-  /**
-   * Get the virtual (capped) content height for DOM use.
-   */
-  getVirtualHeight(): number;
-  /**
-   * Get the scroll ratio used for scroll virtualization.
-   * Returns 1 when no virtualization is needed, < 1 when content exceeds browser limits.
-   */
-  getScrollRatio(): number;
-  /**
-   * Get the visible row range (excluding overscan).
-   * Returns the first and last row indices that are actually visible in the viewport.
-   * Includes partially visible rows to avoid false positives when clicking on edge rows.
-   */
-  getVisibleRowRange(): {
-    start: number;
-    end: number;
-  };
-  /**
-   * Get the scroll position needed to bring a row into view.
-   * Accounts for scroll scaling when active.
-   */
-  getScrollTopForRow(rowIndex: number): number;
-  /**
-   * Get the row index at a given viewport Y position.
-   * Accounts for scroll scaling when active.
-   * @param viewportY Y position in viewport (physical pixels below header, NOT including scroll)
-   * @param virtualScrollTop Current scroll position from container.scrollTop (virtual/scaled)
-   */
-  getRowIndexAtDisplayY(viewportY: number, virtualScrollTop: number): number;
-}
-//#endregion
 //#region src/managers/sort-filter-manager.d.ts
 interface SortFilterManagerOptions<TData> {
   /** Get all columns */
@@ -1523,7 +1231,7 @@ declare class SortFilterManager<TData = Record<string, unknown>> {
   constructor(options: SortFilterManagerOptions<TData>);
   setSort(colId: string, direction: SortDirection | null, addToExisting?: boolean): Promise<void>;
   getSortModel(): SortModel[];
-  setFilter(colId: string, filter: ColumnFilterModel | string | null): Promise<void>;
+  setFilter(colId: string, filter: ColumnFilterInput | string | null): Promise<void>;
   /**
    * Lint for hand-constructed filter models: values-mode `selectedValues`
    * match by strict raw identity (`"5"` never matches `5`, an ISO string
@@ -1620,189 +1328,48 @@ interface IndexedDataStoreOptions<TData> {
   getRowId: (row: TData) => RowId;
   /** Custom field accessor for nested properties */
   getFieldValue?: (row: TData, field: string) => CellValue;
-  /**
-   * Lookup for a field's valueFormatter. Lets free-text filter conditions
-   * compare against the displayed (formatted) value. Values-mode
-   * `selectedValues` compare raw values and never use it.
-   */
-  getValueFormatter?: (field: string) => ((v: CellValue) => string) | undefined;
-}
-/** Hash cache for a single row */
-interface RowSortCache {
-  /** Map: sortModelHash -> computed hashes for that sort configuration */
-  hashes: Map<string, number[]>;
 }
 /**
- * Efficient data structure for incremental operations on grid data.
- * Supports:
- * - O(1) lookup by row ID
- * - O(log n) binary insertion to maintain sort order
- * - Filter state caching with distinct values
- * - Hash caching for fast sorted comparisons
+ * Row registry backing the mutable client data source.
+ *
+ * Holds rows in insertion order with an id → index map for O(1) lookup and a
+ * refcounted distinct-value index per field (for filter UIs). Sorting and
+ * filtering are applied by the data source on top of `getAllRows()`.
  */
 declare class IndexedDataStore<TData = unknown> {
   private rows;
   private readonly rowById;
-  private sortedIndices;
-  private sortModel;
-  private sortModelHash;
-  private filterModel;
-  private filteredIndices;
   private readonly distinctValues;
-  private rowSortCache;
   private readonly options;
   constructor(options: IndexedDataStoreOptions<TData>, initialData?: TData[]);
-  /**
-   * Clear all data and internal caches.
-   * Used for proper memory cleanup when the store is no longer needed.
-   */
+  /** Clear all data and internal indexes. */
   clear(): void;
-  /**
-   * Replace all data (used for initial load or full refresh).
-   */
+  /** Replace all data (used for initial load or full refresh). */
   setData(data: TData[]): void;
-  /**
-   * Query data with sorting, filtering, and row-range slicing.
-   * Compatible with DataSource.query() interface.
-   */
-  query(request: DataSourceRequest): DataSourceResponse<TData>;
-  /**
-   * Get row by ID.
-   */
   getRowById(id: RowId): TData | undefined;
-  /**
-   * Get row by index.
-   */
-  getRowByIndex(index: number): TData | undefined;
-  /**
-   * Get total row count (unfiltered).
-   */
   getTotalRowCount(): number;
-  /**
-   * Get all rows as a new array.
-   * Used for direct data access when bypassing store's query system.
-   */
+  /** All rows, in storage order, as a new array. */
   getAllRows(): TData[];
-  /**
-   * Move a row from one position to another in the raw data array.
-   * This reorders the underlying data; when no sort is active, the new order
-   * is reflected immediately on the next fetch.
-   */
-  moveRow(fromIndex: number, toIndex: number): void;
-  /**
-   * Get visible row count (after filtering).
-   */
-  getVisibleRowCount(): number;
-  /**
-   * Get distinct values for a field (for filter UI).
-   */
+  /** Distinct values for a field (for filter UI). */
   getDistinctValues(field: string): CellValue[];
-  /**
-   * Add rows to the store.
-   * Rows are inserted at their correct sorted position.
-   */
+  /** Append rows. Rows whose id already exists are skipped with a warning. */
   addRows(rows: TData[]): void;
-  /**
-   * Add a single row.
-   */
   private addRow;
   /**
-   * Remove rows by ID. Returns the number of rows actually removed (unknown
-   * ids are ignored).
+   * Remove rows by ID in a single pass. Returns the number of rows actually
+   * removed (unknown ids are ignored).
    */
   removeRows(ids: RowId[]): number;
-  /**
-   * Remove a single row by index.
-   */
-  private removeRowByIndex;
-  /**
-   * Update indices after a row removal.
-   */
-  private reindexAfterRemoval;
-  /**
-   * Update a cell value.
-   */
+  /** Update a single field on a row, keeping the distinct-value index in sync. */
   updateCell(id: RowId, field: string, value: CellValue): void;
-  /**
-   * Update multiple fields on a row.
-   */
+  /** Update multiple fields on a row. */
   updateRow(id: RowId, data: Partial<TData>): void;
   /**
-   * Set the sort model. Triggers full re-sort if model changed.
-   */
-  setSortModel(model: SortModel[]): void;
-  /**
-   * Get current sort model.
-   */
-  getSortModel(): SortModel[];
-  /**
-   * Set the filter model.
-   */
-  setFilterModel(model: FilterModel): void;
-  /**
-   * Get current filter model.
-   */
-  getFilterModel(): FilterModel;
-  /**
-   * Rebuild sorted indices (full re-sort).
-   */
-  private rebuildSortedIndices;
-  /**
-   * Rebuild hash cache for all rows.
-   */
-  private rebuildHashCache;
-  /**
-   * Compute and cache sort hashes for a row.
-   */
-  private computeRowHashes;
-  /**
-   * Compare two rows using cached hashes.
-   */
-  private compareRows;
-  /**
-   * Binary search for insertion position in sortedIndices.
-   */
-  private binarySearchInsertPosition;
-  /**
-   * Rebuild filtered indices.
-   */
-  private rebuildFilteredIndices;
-  /**
-   * Check if a row passes the current filter.
-   */
-  private rowPassesFilter;
-  /**
-   * Get visible indices (filtered + sorted).
-   */
-  private getVisibleIndices;
-  /**
-   * Rebuild distinct values cache for all fields.
-   */
-  private rebuildDistinctValues;
-  /**
-   * Update distinct-value refcounts when a row is added or removed.
-   * Skips null/undefined cell values — they never enter the filter popup.
-   */
-  private updateDistinctValuesForRow;
-  /**
-   * Update distinct-value refcounts when a cell value changes: decrement
-   * the old value's count (evicting it if this was the last reference)
-   * and increment the new value's count.
-   */
-  private updateDistinctValueForField;
-  /**
-   * Add a value (scalar or array) to the distinct-value refcount map.
-   * Creates the field's count map lazily. For arrays, each non-null item
-   * is counted individually so tag-column filters see element-level
-   * distinct values.
-   */
-  private addToDistinctValues;
-  /**
-   * Decrement refcount(s) for a value (scalar or array). When a count
-   * reaches zero the key is deleted so getDistinctValues() no longer
-   * returns stale values after the last holder is removed.
+   * Move a row from one position to another in storage order. When no sort
+   * is active the new order is reflected on the next fetch.
    */
-  private decrementDistinctValues;
+  moveRow(fromIndex: number, toIndex: number): void;
+  private rebuildIdIndex;
 }
 //#endregion
 //#region src/indexed-data-store/field-helpers.d.ts
@@ -1822,23 +1389,6 @@ declare function getFieldValue<TData>(row: TData, field: string): CellValue;
  */
 declare function setFieldValue<TData>(row: TData, field: string, value: CellValue): void;
 //#endregion
-//#region src/indexed-data-store/sorting.d.ts
-/**
- * Convert a string to a sortable number using first 10 characters.
- * Uses base-36 encoding (a-z = 0-25, 0-9 = 26-35).
- */
-declare function stringToSortableNumber(str: string): number;
-/**
- * Compare two cell values for sorting.
- * Handles null/undefined, arrays, numbers, dates, and strings.
- */
-declare function compareValues(a: CellValue, b: CellValue): number;
-/**
- * Compute a sortable hash for a cell value.
- * Used for fast comparisons in sorted indices.
- */
-declare function computeValueHash(value: CellValue): number;
-//#endregion
 //#region src/filtering/index.d.ts
 /**
  * Check if two dates are on the same day.
@@ -1863,12 +1413,12 @@ declare function evaluateNumberCondition(cellValue: CellValue, condition: Number
  */
 declare function evaluateDateCondition(cellValue: CellValue, condition: DateFilterCondition): boolean;
 /**
- * Evaluate a column filter model against a cell value.
- * Uses left-to-right evaluation with per-condition operators.
- * When `formatter` is provided, text conditions compare against the formatted
- * display value rather than the raw string.
+ * Evaluate a column filter model against a cell value. Conditions are joined
+ * inside their explicit group, then groups are joined at the model level.
+ * Legacy flat inputs retain their historical left-to-right truth table by
+ * first normalizing to an equivalent grouped model.
  */
-declare function evaluateColumnFilter(cellValue: CellValue, filter: ColumnFilterModel, formatter?: (v: CellValue) => string): boolean;
+declare function evaluateColumnFilter(cellValue: CellValue, filter: ColumnFilterInput, formatter?: (v: CellValue) => string): boolean;
 /**
  * Check if a row passes all filters in a filter model.
  * `getValueFormatter` — when provided — lets free-text condition operators
@@ -1969,18 +1519,10 @@ declare class TransactionManager<TData = unknown> {
 //#endregion
 //#region src/grid-core.d.ts
 declare class GridCore<TData = unknown> {
+  private readonly config;
   private columns;
-  private readonly rowHeight;
-  private readonly headerHeight;
-  private readonly overscan;
-  private readonly maxFlingVelocity;
-  private readonly sortingEnabled;
-  private readonly getRowId?;
-  private readonly onCellValueChanged?;
-  private readonly rowDragEntireRow;
-  private readonly onRowDragEnd?;
-  private readonly onColumnResized?;
-  private readonly onColumnMoved?;
+  private columnPositions;
+  private readonly batcher;
   private readonly viewport;
   private scrollTopOverride;
   private readonly rowData;
@@ -1989,14 +1531,11 @@ declare class GridCore<TData = unknown> {
   readonly input: InputHandler<TData>;
   readonly highlight: HighlightManager<TData> | null;
   readonly sortFilter: SortFilterManager<TData>;
-  readonly rowMutation: RowMutationManager<TData>;
   private readonly slotPool;
   private readonly editManager;
-  private columnPositions;
-  private readonly batcher;
   private readonly scrollVirtualization;
+  private readonly view;
   private isDestroyed;
-  private hasWarnedAboutScaledOverscan;
   constructor(options: GridCoreOptions<TData>);
   /**
    * Subscribe to batched instructions for efficient React/Vue state updates.
@@ -2013,9 +1552,8 @@ declare class GridCore<TData = unknown> {
    */
   setViewport(scrollTop: number, scrollLeft: number, width: number, height: number): void;
   setSort(colId: string, direction: SortDirection | null, addToExisting?: boolean): Promise<void>;
-  setFilter(colId: string, filter: ColumnFilterModel | string | null): Promise<void>;
+  setFilter(colId: string, filter: ColumnFilterInput | string | null): Promise<void>;
   hasActiveFilter(colId: string): boolean;
-  getDistinctValuesForColumn(colId: string, maxValues?: number): CellValue[];
   /**
    * Open a column filter popup.
    * Adapters can skip distinct-value computation when their popup only uses
@@ -2053,15 +1591,7 @@ declare class GridCore<TData = unknown> {
   setCellValue(row: number, col: number, value: CellValue): void;
   private clearSelectionIfInvalid;
   private computeColumnPositions;
-  private emitContentSize;
-  /**
-   * One-time advisory when scroll virtualization kicks in with a small
-   * overscan: momentum flings move several rows per frame at that scale,
-   * and a small overscan shows blank rows behind the fling.
-   */
-  private warnIfOverscanTooLowForScaling;
-  private emitHeaders;
-  private emitVisibleRange;
+  private columnOperationDeps;
   /**
    * Set the displayed width of a column and recompute layout. `width` is the
    * post-redistribution displayed width — the stored `column.width` is
@@ -2098,12 +1628,12 @@ declare class GridCore<TData = unknown> {
    * synthetic scroller while scroll virtualization is active.
    */
   getMaxFlingVelocity(): number;
-  getNaturalHeight(): number;
   getScrollRatio(): number;
   getVisibleRowRange(): {
     start: number;
     end: number;
   };
+  /** Used structurally by `scrollCellIntoView` in the framework wrappers. */
   getScrollTopForRow(rowIndex: number): number;
   getRowIndexAtDisplayY(viewportY: number, virtualScrollTop: number): number;
   /**
@@ -2127,31 +1657,6 @@ declare class GridCore<TData = unknown> {
    * Useful after in-place data modifications like fill operations.
    */
   refreshSlotData(): void;
-  /**
-   * Add rows to the grid at the specified index.
-   * If no index is provided, rows are added at the end.
-   */
-  addRows(rows: TData[], index?: number): void;
-  /**
-   * Update existing rows with partial data.
-   */
-  updateRows(updates: Array<{
-    index: number;
-    data: Partial<TData>;
-  }>): void;
-  /**
-   * Delete rows at the specified indices.
-   */
-  deleteRows(indices: number[]): void;
-  /**
-   * Get a row by index.
-   */
-  getRow(index: number): TData | undefined;
-  /**
-   * Set a complete row at the specified index.
-   * Use this for complete row replacement. For partial updates, use updateRows.
-   */
-  setRow(index: number, data: TData): void;
   /**
    * Update the data source and refresh.
    * Preserves grid state (sort, filter, scroll position).
@@ -2170,31 +1675,196 @@ declare class GridCore<TData = unknown> {
   destroy(): void;
 }
 //#endregion
-//#region src/utils/positioning.d.ts
-/**
- * Calculate cumulative column positions (prefix sums)
- * Returns an array where positions[i] is the left position of column i
- * positions[columns.length] is the total width
- */
-declare const calculateColumnPositions: (columns: ColumnDefinition[]) => number[];
-/**
- * Get total width from column positions
- */
-declare const getTotalWidth: (columnPositions: number[]) => number;
-/**
- * Calculate scaled column positions when container is wider than total column widths.
- * Columns expand proportionally based on their original width ratios.
- *
- * @param columns - Column definitions with original widths
- * @param containerWidth - Available container width
- * @returns Object with positions array and widths array
- */
-declare const calculateScaledColumnPositions: (columns: ColumnDefinition[], containerWidth: number) => {
-  positions: number[];
-  widths: number[];
-};
-/**
- * Find column index at a given X coordinate
+//#region src/sorting/parallel-sort-manager.d.ts
+interface ParallelSortOptions {
+  /** Maximum number of workers (default: navigator.hardwareConcurrency || 4) */
+  maxWorkers?: number;
+  /** Threshold for parallel sorting (default: 400000) */
+  parallelThreshold?: number;
+  /** Minimum chunk size (default: 50000) */
+  minChunkSize?: number;
+}
+//#endregion
+//#region src/data-source/client-data-source.d.ts
+interface ClientDataSourceOptions<TData> {
+  /** Custom field accessor for nested properties */
+  getFieldValue?: (row: TData, field: string) => CellValue;
+  /**
+   * Lookup for a field's valueFormatter. Lets free-text filter conditions
+   * compare against the displayed (formatted) value the user typed against.
+   * Values-mode `selectedValues` compare raw values and never use it.
+   */
+  getValueFormatter?: (field: string) => ((v: CellValue) => string) | undefined;
+  /** Use Web Worker for sorting large datasets (default: true) */
+  useWorker?: boolean;
+  /** Options for parallel sorting (only used when useWorker is true) */
+  parallelSort?: ParallelSortOptions | false;
+}
+/**
+ * Creates a client-side data source that holds all data in memory.
+ * Sorting and filtering are performed client-side.
+ * For large datasets, sorting is automatically offloaded to a Web Worker.
+ */
+declare function createClientDataSource<TData = unknown>(data: TData[], options?: ClientDataSourceOptions<TData>): DataSource<TData>;
+/**
+ * Convenience function to create a data source from an array.
+ * This provides backwards compatibility with the old `rowData` prop.
+ */
+declare function createDataSourceFromArray<TData = unknown>(data: TData[]): DataSource<TData>;
+//#endregion
+//#region src/data-source/server-data-source.d.ts
+type ServerQueryFunction<TData> = (request: DataSourceRequest) => Promise<DataSourceResponse<TData>>;
+interface ServerDataSourceOptions {
+  /** Server data sources use paginated loading by default. */
+  loadMode?: DataSourceLoadMode;
+}
+/**
+ * Creates a server-side data source that delegates all operations to the server.
+ * The query function receives sort/filter/range params to pass to the API.
+ */
+declare function createServerDataSource<TData = unknown>(queryFn: ServerQueryFunction<TData>, options?: ServerDataSourceOptions): DataSource<TData>;
+//#endregion
+//#region src/data-source/mutable-data-source.d.ts
+/** Callback for data change notifications */
+type DataChangeListener = (result: TransactionResult) => void;
+/**
+ * Data source with mutation capabilities.
+ * Extends DataSource with add, remove, and update operations.
+ */
+interface MutableDataSource<TData = unknown> extends DataSource<TData> {
+  /** Add rows to the data source. Queued and processed after debounce. */
+  addRows(rows: TData[]): void;
+  /** Remove rows by ID. Queued and processed after debounce. */
+  removeRows(ids: RowId[]): void;
+  /** Update a cell value. Queued and processed after debounce. */
+  updateCell(id: RowId, field: string, value: CellValue): void;
+  /** Update multiple fields on a row. Queued and processed after debounce. */
+  updateRow(id: RowId, data: Partial<TData>): void;
+  /** Force immediate processing of queued transactions. */
+  flushTransactions(): Promise<void>;
+  /** Check if there are pending transactions. */
+  hasPendingTransactions(): boolean;
+  /** Get distinct values for a field (for filter UI). */
+  getDistinctValues(field: string): CellValue[];
+  /** Get a row by ID. */
+  getRowById(id: RowId): TData | undefined;
+  /** Get total row count. */
+  getTotalRowCount(): number;
+  /** Subscribe to data change notifications. Returns unsubscribe function. */
+  subscribe(listener: DataChangeListener): () => void;
+  /** Clear all data from the data source. */
+  clear(): void;
+  /** Move a row from one display position to another. */
+  moveRow(fromIndex: number, toIndex: number): void;
+}
+interface MutableClientDataSourceOptions<TData> {
+  /** Function to extract unique ID from row. Required. */
+  getRowId: (row: TData) => RowId;
+  /** Custom field accessor for nested properties. */
+  getFieldValue?: (row: TData, field: string) => CellValue;
+  /**
+   * Lookup for a field's valueFormatter. Lets free-text filter conditions
+   * compare against the displayed (formatted) value. Values-mode
+   * `selectedValues` compare raw values and never use it.
+   */
+  getValueFormatter?: (field: string) => ((v: CellValue) => string) | undefined;
+  /** Debounce time for transactions in ms. Default 50. Set to 0 for sync. */
+  debounceMs?: number;
+  /** Callback when transactions are processed. */
+  onTransactionProcessed?: (result: TransactionResult) => void;
+  /** Use Web Worker for sorting large datasets (default: true) */
+  useWorker?: boolean;
+  /** Options for parallel sorting (only used when useWorker is true) */
+  parallelSort?: ParallelSortOptions | false;
+}
+/**
+ * Creates a mutable client-side data source with transaction support.
+ * Uses IndexedDataStore for efficient incremental operations.
+ * For large datasets, sorting is automatically offloaded to a Web Worker.
+ */
+declare function createMutableClientDataSource<TData = unknown>(data: TData[], options: MutableClientDataSourceOptions<TData>): MutableDataSource<TData>;
+//#endregion
+//#region src/filtering/normalize.d.ts
+/** Check whether a filter still uses the legacy flat condition list. */
+declare const isLegacyColumnFilterModel: (filter: ColumnFilterInput) => filter is LegacyColumnFilterModel;
+/**
+ * Convert a legacy left-to-right filter into the canonical one-level grouped
+ * representation. Canonical inputs are returned unchanged.
+ */
+declare const normalizeColumnFilterModel: (filter: ColumnFilterInput) => ColumnFilterModel;
+//#endregion
+//#region src/filtering/distinct-entries.d.ts
+/** One checkbox row in the values-mode filter popup. */
+interface DistinctValueEntry {
+  /** Formatted display string shown next to the checkbox. */
+  label: string;
+  /** All raw values that format to this label. Ticking the label selects them all. */
+  values: CellValue[];
+}
+/**
+ * Canonical identity key for a raw cell value, used to compare values-mode
+ * selections against cell values without ever consulting a formatter.
+ *
+ * Type-prefixed so raw `5` and raw `"5"` never collide. Arrays are sorted by
+ * their elements' own keys first so element order is irrelevant (same rule as
+ * the distinct-value scan). Objects rely on JSON.stringify, so key order matters
+ * for them — a pre-existing limitation of distinct-value identity.
+ */
+declare const rawValueKey: (value: CellValue) => string;
+/**
+ * Whether a cell value counts as blank for filtering purposes: null,
+ * undefined, empty string, or empty array (e.g. a tags column with no tags).
+ * Blank cells are matched via `TextFilterCondition.includeBlank` — the
+ * popup's "(Blanks)" checkbox — never via `selectedValues`.
+ */
+declare const isBlankCellValue: (value: CellValue) => boolean;
+/**
+ * Group raw distinct values by their display label.
+ *
+ * Multiple raw values can format to the same label; the returned entry keeps
+ * every one of them so that applying the filter selects all rows rendering
+ * that label. Blank values are skipped (the popup exposes them through the
+ * dedicated "include blanks" checkbox), arrays are normalized to sorted
+ * copies, and raws are deduplicated within a group by {@link rawValueKey}.
+ */
+declare const groupDistinctValues: (values: readonly CellValue[], formatter?: (v: CellValue) => string) => DistinctValueEntry[];
+/**
+ * Map a filter model's raw `selectedValues` back to the popup labels that
+ * should render as ticked. A label is ticked when at least one of its raw
+ * values is selected (data may have changed since the filter was applied).
+ */
+declare const labelsForSelectedValues: (entries: readonly DistinctValueEntry[], selectedValues: ReadonlySet<CellValue>) => Set<string>;
+/**
+ * Collect the raw values behind the ticked labels — the set to store in
+ * `TextFilterCondition.selectedValues` on apply.
+ */
+declare const rawValuesForLabels: (entries: readonly DistinctValueEntry[], labels: ReadonlySet<string>) => Set<CellValue>;
+//#endregion
+//#region src/utils/positioning.d.ts
+/**
+ * Calculate cumulative column positions (prefix sums)
+ * Returns an array where positions[i] is the left position of column i
+ * positions[columns.length] is the total width
+ */
+declare const calculateColumnPositions: (columns: ColumnDefinition[]) => number[];
+/**
+ * Get total width from column positions
+ */
+declare const getTotalWidth: (columnPositions: number[]) => number;
+/**
+ * Calculate scaled column positions when container is wider than total column widths.
+ * Columns expand proportionally based on their original width ratios.
+ *
+ * @param columns - Column definitions with original widths
+ * @param containerWidth - Available container width
+ * @returns Object with positions array and widths array
+ */
+declare const calculateScaledColumnPositions: (columns: ColumnDefinition[], containerWidth: number) => {
+  positions: number[];
+  widths: number[];
+};
+/**
+ * Find column index at a given X coordinate
  */
 declare const findColumnAtX: (x: number, columnPositions: number[]) => number;
 //#endregion
@@ -2232,20 +1902,6 @@ declare const isCellInFillPreview: (row: number, col: number, isDraggingFill: bo
  * Build cell CSS classes based on state
  */
 declare const buildCellClasses: (isActive: boolean, isSelected: boolean, isEditing: boolean, inFillPreview: boolean) => string;
-/**
- * Check if a row overlaps the selection range
- */
-declare const isRowInSelectionRange: (rowIndex: number, range: CellRange | null) => boolean;
-/**
- * Check if a column overlaps the selection range
- */
-declare const isColumnInSelectionRange: (colIndex: number, range: CellRange | null) => boolean;
-//#endregion
-//#region src/utils/event-emitter.d.ts
-/**
- * Batch instruction listener for efficient state updates
- */
-type BatchInstructionListener$1 = (instructions: GridInstruction[]) => void;
 //#endregion
 //#region src/types/ui-state.d.ts
 interface SlotData<TData = unknown> {
@@ -2315,11 +1971,16 @@ interface GridState<TData = unknown> {
   pendingScrollTop: number | null;
 }
 //#endregion
-//#region src/utils/scroll-helpers.d.ts
+//#region src/state-reducer.d.ts
 /**
- * Find the slot for a given row index
+ * Apply a single instruction to mutable slot/header Maps and return
+ * other state changes as a partial object.
+ *
+ * Returns `null` when only the Maps were mutated (no primitive field changes).
  */
-declare const findSlotForRow: (slots: Map<string, SlotData>, rowIndex: number) => SlotData | null;
+declare const applyInstruction: <TData = unknown>(instruction: GridInstruction, slots: Map<string, SlotData<TData>>, headers: Map<number, HeaderData>) => Partial<GridState<TData>> | null;
+//#endregion
+//#region src/utils/scroll-helpers.d.ts
 /**
  * Column geometry needed to scroll a cell horizontally into view.
  * Columns are not scroll-virtualized, so positions map 1:1 to scrollLeft.
@@ -2427,500 +2088,6 @@ declare const calculateFilterPopupPosition: (headerCell: HTMLElement, popupEl: H
  */
 declare const bindPeekSelectAll: (overlay: HTMLElement) => (() => void);
 //#endregion
-//#region src/slot-pool.d.ts
-interface SlotPoolManagerOptions {
-  /** Get current row height */
-  getRowHeight: () => number;
-  /** Get current header height */
-  getHeaderHeight: () => number;
-  /** Get overscan count */
-  getOverscan: () => number;
-  /** Get current scroll top position (natural, not virtual) */
-  getScrollTop: () => number;
-  /** Get viewport height */
-  getViewportHeight: () => number;
-  /** Get total row count */
-  getTotalRows: () => number;
-  /** Get scroll ratio for virtualization (1 = no virtualization) */
-  getScrollRatio: () => number;
-  /** Get virtual content height */
-  getVirtualContentHeight: () => number;
-  /** Get row data by index */
-  getRowData: (rowIndex: number) => unknown;
-}
-/**
- * Manages the slot pool for virtual scrolling.
- * Handles slot creation, recycling, positioning, and destruction.
- */
-declare class SlotPoolManager {
-  private readonly state;
-  private readonly options;
-  private readonly emitter;
-  private isDestroyed;
-  onInstruction: (listener: InstructionListener) => () => void;
-  onBatchInstruction: (listener: BatchInstructionListener$1) => () => void;
-  private readonly emit;
-  private readonly emitBatch;
-  constructor(options: SlotPoolManagerOptions);
-  /**
-   * Get the slot ID for a given row index.
-   */
-  getSlotForRow(rowIndex: number): string | undefined;
-  /**
-   * Get all current slots.
-   */
-  getSlots(): Map<string, SlotState>;
-  /**
-   * Synchronize slots with current viewport position.
-   * This implements the slot recycling strategy.
-   */
-  syncSlots(): void;
-  /**
-   * Partition existing slots into recyclable and still-needed.
-   * Mutates requiredRows: rows that already have a slot are removed.
-   */
-  private partitionSlots;
-  /**
-   * Assign a row to a recycled or newly created slot.
-   */
-  private assignSlotToRow;
-  /**
-   * Push MOVE_SLOT instructions for slots whose position has drifted.
-   */
-  private updateSlotPositions;
-  /**
-   * Destroy all slots.
-   */
-  destroyAllSlots(): void;
-  /**
-   * Clean up resources for garbage collection.
-   * This method is idempotent - safe to call multiple times.
-   */
-  destroy(): void;
-  /**
-   * Refresh all slot data without changing which rows are displayed.
-   * Used after filtering/sorting when data changes.
-   */
-  refreshAllSlots(): void;
-  /**
-   * Update a single slot's data.
-   */
-  updateSlot(rowIndex: number): void;
-  /**
-   * Calculate the translateY position for a row.
-   * Handles scroll virtualization for very large datasets.
-   *
-   * When virtualization is active (scrollRatio < 1), we use viewport-relative
-   * positioning to keep translateY values small. This prevents browser rendering
-   * issues that occur at extreme pixel values (millions of pixels).
-   *
-   * Note: The header is rendered outside the content sizer, so row positions
-   * start at 0 (not headerHeight) within the rows container.
-   */
-  private getRowTranslateY;
-  /**
-   * Get the translateY position for a row inside the rows wrapper.
-   * Public accessor for use by input handler (e.g., drop indicator positioning).
-   */
-  getRowTranslateYForIndex(rowIndex: number): number;
-  /**
-   * Get the Y offset for the rows wrapper container.
-   * When virtualization is active, this positions the wrapper so rows
-   * with small translateY values appear at the correct scroll position.
-   */
-  getRowsWrapperOffset(): number;
-}
-//#endregion
-//#region src/edit-manager.d.ts
-interface EditManagerOptions {
-  /** Get column definition by index */
-  getColumn: (colIndex: number) => ColumnDefinition | undefined;
-  /** Get cell value */
-  getCellValue: (row: number, col: number) => CellValue;
-  /** Set cell value */
-  setCellValue: (row: number, col: number, value: CellValue) => void;
-  /** Callback when edit is committed (to update slot display) */
-  onCommit?: (row: number, col: number, value: CellValue) => void;
-}
-/**
- * Manages cell editing state and operations.
- */
-declare class EditManager {
-  private editState;
-  private peekState;
-  private readonly options;
-  private readonly emitter;
-  onInstruction: (listener: InstructionListener) => () => void;
-  private readonly emit;
-  constructor(options: EditManagerOptions);
-  /**
-   * Get the current edit state.
-   */
-  getState(): EditState | null;
-  /**
-   * Check if currently editing.
-   */
-  isEditing(): boolean;
-  /**
-   * Check if a specific cell is being edited.
-   */
-  isEditingCell(row: number, col: number): boolean;
-  /**
-   * Start editing a cell.
-   * Returns true if edit was started, false if cell is not editable.
-   */
-  startEdit(row: number, col: number): boolean;
-  /**
-   * Get the cell currently shown in a peek overlay, or null.
-   */
-  getPeekState(): CellPosition | null;
-  /**
-   * Open a peek overlay on a cell. Caller is responsible for guarding on
-   * `column.peekable` — the manager only refuses when an edit is in progress
-   * (edit and peek are mutually exclusive).
-   * Returns true if the peek was opened.
-   */
-  startPeek(row: number, col: number): boolean;
-  /**
-   * Close any active peek overlay. No-op if none is open.
-   */
-  stopPeek(): void;
-  /**
-   * Update the current edit value.
-   */
-  updateValue(value: CellValue): void;
-  /**
-   * Commit the current edit.
-   * Saves the value and closes the editor.
-   */
-  commit(): void;
-  /**
-   * Cancel the current edit.
-   * Discards changes and closes the editor.
-   */
-  cancel(): void;
-  /**
-   * Clean up resources for garbage collection.
-   */
-  destroy(): void;
-}
-//#endregion
-//#region src/sorting/parallel-sort-manager.d.ts
-interface ParallelSortOptions {
-  /** Maximum number of workers (default: navigator.hardwareConcurrency || 4) */
-  maxWorkers?: number;
-  /** Threshold for parallel sorting (default: 400000) */
-  parallelThreshold?: number;
-  /** Minimum chunk size (default: 50000) */
-  minChunkSize?: number;
-}
-/**
- * Manages parallel sorting operations using a worker pool.
- * Automatically decides between single-worker and parallel sorting based on data size.
- */
-declare class ParallelSortManager {
-  private readonly pool;
-  private readonly parallelThreshold;
-  private readonly minChunkSize;
-  private isTerminated;
-  constructor(options?: ParallelSortOptions);
-  isAvailable(): boolean;
-  terminate(): void;
-  sortIndices(values: number[], direction: "asc" | "desc"): Promise<Uint32Array>;
-  sortStringHashes(hashChunks: Float64Array[], direction: "asc" | "desc", originalStrings: string[]): Promise<Uint32Array>;
-  sortMultiColumn(columns: number[][], directions: ("asc" | "desc")[]): Promise<Uint32Array>;
-  private assertNotTerminated;
-  private sortIndicesSingle;
-  private sortStringHashesSingle;
-  private sortMultiColumnSingle;
-  private boundariesFor;
-  private runChunks;
-  private sortIndicesParallel;
-  private sortStringHashesParallel;
-  private sortMultiColumnParallel;
-}
-//#endregion
-//#region src/sorting/worker-pool.d.ts
-interface WorkerPoolOptions {
-  /** Maximum number of workers (default: navigator.hardwareConcurrency ?? 4) */
-  maxWorkers?: number;
-  /** Whether to pre-warm workers on initialization */
-  preWarm?: boolean;
-}
-/**
- * Manages a pool of Web Workers for parallel task execution.
- * Workers are created lazily and reused across operations.
- */
-declare class WorkerPool {
-  private readonly workerCode;
-  private readonly maxWorkers;
-  private workers;
-  private workerUrl;
-  private nextRequestId;
-  private isTerminated;
-  constructor(workerCode: string, options?: WorkerPoolOptions);
-  /**
-   * Get the current pool size (number of active workers).
-   */
-  getPoolSize(): number;
-  /**
-   * Get the maximum pool size.
-   */
-  getMaxWorkers(): number;
-  /**
-   * Check if the pool is available for use.
-   */
-  isAvailable(): boolean;
-  /**
-   * Execute a single task on an available worker.
-   * Returns the worker's response.
-   */
-  execute<TRequest extends {
-    id?: number;
-  }, TResponse>(request: TRequest, transferables?: Transferable[]): Promise<TResponse>;
-  /**
-   * Execute multiple tasks in parallel across available workers.
-   * Each task is assigned to a different worker if possible.
-   * Returns results in the same order as the input requests.
-   */
-  executeParallel<TRequest extends {
-    id?: number;
-  }, TResponse>(tasks: Array<{
-    request: TRequest;
-    transferables?: Transferable[];
-  }>): Promise<TResponse[]>;
-  /**
-   * Terminate all workers and clean up resources.
-   */
-  terminate(): void;
-  /**
-   * Pre-warm workers by creating them ahead of time.
-   */
-  private preWarmWorkers;
-  /**
-   * Ensure at least `count` workers exist in the pool.
-   */
-  private ensureWorkers;
-  /**
-   * Get an available worker, creating one if needed.
-   */
-  private getAvailableWorker;
-  /**
-   * Create a new worker and add it to the pool.
-   */
-  private createWorker;
-  /**
-   * Respawn a failed worker.
-   */
-  private respawnWorker;
-}
-//#endregion
-//#region src/sorting/k-way-merge.d.ts
-/**
- * Represents a sorted chunk with its values and offset in the original array.
- */
-interface SortedChunk {
-  /** Sorted indices (local to this chunk) */
-  indices: Uint32Array;
-  /** Values for comparison (in same order as indices) */
-  values: Float64Array;
-  /** Offset of this chunk in the original array */
-  offset: number;
-}
-/**
- * Represents a sorted chunk for multi-column sorting.
- */
-interface MultiColumnSortedChunk {
-  /** Sorted indices (local to this chunk) */
-  indices: Uint32Array;
-  /** Values for comparison - array of columns, each in same order as indices */
-  columns: Float64Array[];
-  /** Sort directions for each column (1 = asc, -1 = desc) */
-  directions: Int8Array;
-  /** Offset of this chunk in the original array */
-  offset: number;
-}
-/**
- * Merge multiple sorted chunks into a single sorted result.
- * Uses a min-heap for O(n log k) time complexity.
- *
- * @param chunks - Array of sorted chunks to merge
- * @param direction - Sort direction ('asc' or 'desc')
- * @returns Uint32Array of globally sorted indices
- */
-declare function kWayMerge(chunks: SortedChunk[], direction: SortDirection): Uint32Array;
-/**
- * Merge multiple sorted chunks for multi-column sorting.
- *
- * @param chunks - Array of multi-column sorted chunks
- * @returns Uint32Array of globally sorted indices
- */
-declare function kWayMergeMultiColumn(chunks: MultiColumnSortedChunk[]): Uint32Array;
-/**
- * Detect collision runs at chunk boundaries after merge.
- * This is used for string sorting where hashes may collide across chunks.
- *
- * @param chunks - Original sorted chunks with their hash values
- * @param _direction - Sort direction
- * @returns Array of boundary collision positions [start1, end1, start2, end2, ...]
- */
-declare function detectBoundaryCollisions(chunks: SortedChunk[], _direction: SortDirection): Uint32Array;
-//#endregion
-//#region src/data-source/client-data-source.d.ts
-interface ClientDataSourceOptions<TData> {
-  /** Custom field accessor for nested properties */
-  getFieldValue?: (row: TData, field: string) => CellValue;
-  /**
-   * Lookup for a field's valueFormatter. Lets free-text filter conditions
-   * compare against the displayed (formatted) value the user typed against.
-   * Values-mode `selectedValues` compare raw values and never use it.
-   */
-  getValueFormatter?: (field: string) => ((v: CellValue) => string) | undefined;
-  /** Use Web Worker for sorting large datasets (default: true) */
-  useWorker?: boolean;
-  /** Options for parallel sorting (only used when useWorker is true) */
-  parallelSort?: ParallelSortOptions | false;
-}
-/**
- * Creates a client-side data source that holds all data in memory.
- * Sorting and filtering are performed client-side.
- * For large datasets, sorting is automatically offloaded to a Web Worker.
- */
-declare function createClientDataSource<TData = unknown>(data: TData[], options?: ClientDataSourceOptions<TData>): DataSource<TData>;
-/**
- * Convenience function to create a data source from an array.
- * This provides backwards compatibility with the old `rowData` prop.
- */
-declare function createDataSourceFromArray<TData = unknown>(data: TData[]): DataSource<TData>;
-//#endregion
-//#region src/data-source/server-data-source.d.ts
-type ServerQueryFunction<TData> = (request: DataSourceRequest) => Promise<DataSourceResponse<TData>>;
-interface ServerDataSourceOptions {
-  /** Server data sources use paginated loading by default. */
-  loadMode?: DataSourceLoadMode;
-}
-/**
- * Creates a server-side data source that delegates all operations to the server.
- * The query function receives sort/filter/range params to pass to the API.
- */
-declare function createServerDataSource<TData = unknown>(queryFn: ServerQueryFunction<TData>, options?: ServerDataSourceOptions): DataSource<TData>;
-//#endregion
-//#region src/data-source/mutable-data-source.d.ts
-/** Callback for data change notifications */
-type DataChangeListener = (result: TransactionResult) => void;
-/**
- * Data source with mutation capabilities.
- * Extends DataSource with add, remove, and update operations.
- */
-interface MutableDataSource<TData = unknown> extends DataSource<TData> {
-  /** Add rows to the data source. Queued and processed after debounce. */
-  addRows(rows: TData[]): void;
-  /** Remove rows by ID. Queued and processed after debounce. */
-  removeRows(ids: RowId[]): void;
-  /** Update a cell value. Queued and processed after debounce. */
-  updateCell(id: RowId, field: string, value: CellValue): void;
-  /** Update multiple fields on a row. Queued and processed after debounce. */
-  updateRow(id: RowId, data: Partial<TData>): void;
-  /** Force immediate processing of queued transactions. */
-  flushTransactions(): Promise<void>;
-  /** Check if there are pending transactions. */
-  hasPendingTransactions(): boolean;
-  /** Get distinct values for a field (for filter UI). */
-  getDistinctValues(field: string): CellValue[];
-  /** Get a row by ID. */
-  getRowById(id: RowId): TData | undefined;
-  /** Get total row count. */
-  getTotalRowCount(): number;
-  /** Subscribe to data change notifications. Returns unsubscribe function. */
-  subscribe(listener: DataChangeListener): () => void;
-  /** Clear all data from the data source. */
-  clear(): void;
-  /** Move a row from one display position to another. */
-  moveRow(fromIndex: number, toIndex: number): void;
-}
-interface MutableClientDataSourceOptions<TData> {
-  /** Function to extract unique ID from row. Required. */
-  getRowId: (row: TData) => RowId;
-  /** Custom field accessor for nested properties. */
-  getFieldValue?: (row: TData, field: string) => CellValue;
-  /**
-   * Lookup for a field's valueFormatter. Lets free-text filter conditions
-   * compare against the displayed (formatted) value. Values-mode
-   * `selectedValues` compare raw values and never use it.
-   */
-  getValueFormatter?: (field: string) => ((v: CellValue) => string) | undefined;
-  /** Debounce time for transactions in ms. Default 50. Set to 0 for sync. */
-  debounceMs?: number;
-  /** Callback when transactions are processed. */
-  onTransactionProcessed?: (result: TransactionResult) => void;
-  /** Use Web Worker for sorting large datasets (default: true) */
-  useWorker?: boolean;
-  /** Options for parallel sorting (only used when useWorker is true) */
-  parallelSort?: ParallelSortOptions | false;
-}
-/**
- * Creates a mutable client-side data source with transaction support.
- * Uses IndexedDataStore for efficient incremental operations.
- * For large datasets, sorting is automatically offloaded to a Web Worker.
- */
-declare function createMutableClientDataSource<TData = unknown>(data: TData[], options: MutableClientDataSourceOptions<TData>): MutableDataSource<TData>;
-//#endregion
-//#region src/filtering/distinct-entries.d.ts
-/** One checkbox row in the values-mode filter popup. */
-interface DistinctValueEntry {
-  /** Formatted display string shown next to the checkbox. */
-  label: string;
-  /** All raw values that format to this label. Ticking the label selects them all. */
-  values: CellValue[];
-}
-/**
- * Canonical identity key for a raw cell value, used to compare values-mode
- * selections against cell values without ever consulting a formatter.
- *
- * Type-prefixed so raw `5` and raw `"5"` never collide. Arrays are sorted by
- * their elements' own keys first so element order is irrelevant (same rule as
- * the distinct-value scan). Objects rely on JSON.stringify, so key order matters
- * for them — a pre-existing limitation of distinct-value identity.
- */
-declare const rawValueKey: (value: CellValue) => string;
-/**
- * Whether a cell value counts as blank for filtering purposes: null,
- * undefined, empty string, or empty array (e.g. a tags column with no tags).
- * Blank cells are matched via `TextFilterCondition.includeBlank` — the
- * popup's "(Blanks)" checkbox — never via `selectedValues`.
- */
-declare const isBlankCellValue: (value: CellValue) => boolean;
-/**
- * Group raw distinct values by their display label.
- *
- * Multiple raw values can format to the same label; the returned entry keeps
- * every one of them so that applying the filter selects all rows rendering
- * that label. Blank values are skipped (the popup exposes them through the
- * dedicated "include blanks" checkbox), arrays are normalized to sorted
- * copies, and raws are deduplicated within a group by {@link rawValueKey}.
- */
-declare const groupDistinctValues: (values: readonly CellValue[], formatter?: (v: CellValue) => string) => DistinctValueEntry[];
-/**
- * Map a filter model's raw `selectedValues` back to the popup labels that
- * should render as ticked. A label is ticked when at least one of its raw
- * values is selected (data may have changed since the filter was applied).
- */
-declare const labelsForSelectedValues: (entries: readonly DistinctValueEntry[], selectedValues: ReadonlySet<CellValue>) => Set<string>;
-/**
- * Collect the raw values behind the ticked labels — the set to store in
- * `TextFilterCondition.selectedValues` on apply.
- */
-declare const rawValuesForLabels: (entries: readonly DistinctValueEntry[], labels: ReadonlySet<string>) => Set<CellValue>;
-//#endregion
-//#region src/state-reducer.d.ts
-/**
- * Apply a single instruction to mutable slot/header Maps and return
- * other state changes as a partial object.
- *
- * Returns `null` when only the Maps were mutated (no primitive field changes).
- */
-declare const applyInstruction: <TData = unknown>(instruction: GridInstruction, slots: Map<string, SlotData<TData>>, headers: Map<number, HeaderData>) => Partial<GridState<TData>> | null;
-//#endregion
 //#region src/i18n.d.ts
 /** Labels for the filter operator dropdowns, keyed by semantic meaning. */
 interface GridFilterOperatorLabels {
@@ -2971,6 +2138,10 @@ interface GridLabels {
   addCondition: string;
   /** Remove-condition button glyph */
   removeCondition: string;
+  /** "+ Add group" button */
+  addGroup: string;
+  /** Remove-group button glyph */
+  removeGroup: string;
   /** Clear button */
   clear: string;
   /** Apply button */
@@ -2996,6 +2167,13 @@ interface GridLabels {
   /** Filter operator labels */
   operators: GridFilterOperatorLabels;
 }
+/**
+ * Consumer overrides for grid labels. Every top-level label and every nested
+ * operator label can be changed independently.
+ */
+type GridLabelOverrides = Omit<Partial<GridLabels>, "operators"> & {
+  operators?: Partial<GridFilterOperatorLabels>;
+};
 /** English defaults for every grid label. */
 declare const defaultGridLabels: GridLabels;
 /**
@@ -3003,7 +2181,7 @@ declare const defaultGridLabels: GridLabels;
  * `GridLabels`. Top-level keys are shallow-merged and `operators` is merged
  * one level deep; the defaults are never mutated.
  */
-declare const resolveGridLabels: (overrides?: Partial<GridLabels>) => GridLabels;
+declare const resolveGridLabels: (overrides?: GridLabelOverrides) => GridLabels;
 /**
  * Interpolate `{token}` placeholders in a label template. Unknown tokens are
  * left untouched and missing params are skipped, so this never throws.
@@ -3143,93 +2321,49 @@ interface TouchScrollDeps<TData = unknown> {
  * touchmove and the end listeners are attached per-gesture, and only when
  * scaling is active — small grids keep fully native, compositor-driven
  * scrolling with zero added cost.
+ *
+ * Collaborators: `TouchPolicy` owns the element's touch-action policy,
+ * `SyntheticScroll` bridges the fractional position to the core, and
+ * `FlingAnimator` runs the release momentum.
  */
 declare class TouchScrollController<TData = unknown> {
   private readonly deps;
+  private readonly scroll;
+  private readonly fling;
   private attachedEl;
+  private policy;
   private gesture;
   private gestureCleanup;
-  private flingFrame;
-  private flingVelocity;
   private dragFrame;
   private pendingDragTarget;
-  private savedOverscrollBehavior;
-  private savedTouchAction;
-  private overrideActive;
-  /** Core whose batch instructions currently drive eager policy syncs */
-  private subscribedCore;
-  private contentSizeUnsubscribe;
-  /** Timestamp of the last slot/render pipeline run (drag or fling) */
-  private lastPipelineRunMs;
-  /** Smoothed interval between pipeline runs — the device's render pace */
-  private pipelineIntervalEmaMs;
-  /** Smoothed rAF frame interval measured while a fling ticks */
-  private frameIntervalEmaMs;
-  /** Latched when measured frames prove per-frame rendering unsustainable */
-  private flingThrottled;
   constructor(deps: TouchScrollDeps<TData>);
   attach(): void;
   detach(): void;
   /** Rebind policy updates after the host replaces its GridCore instance. */
   syncCore(): void;
-  /**
-   * Keep the eager policy sync subscribed to the current core. Browsers —
-   * iOS Safari especially — sample `touch-action` at gesture start, so a
-   * policy applied inside touchstart only takes effect from the NEXT
-   * gesture. Subscribing to the core's content-size instructions applies
-   * the policy the moment scaling flips, before any finger goes down.
-   * Re-invoked through syncCore when the wrapper rebuilds the core, and from
-   * the permanent listeners as a fallback.
-   */
-  private syncPolicySubscription;
-  /**
-   * While scroll scaling is active, panning must never be native: declare
-   * `touch-action: none` so the browser cannot start a (ratio-amplified)
-   * native scroll at all, and contain overscroll so synthetic flings do not
-   * chain to the page. Non-scaled grids keep their original native policy.
-   */
-  private syncTouchPolicy;
   /** Cancel an in-flight fling (call before programmatic scrollTop writes). */
   stop(): void;
-  /**
-   * Drive the grid from the synthetic (fractional) scroll position. The DOM
-   * scrollTop write is quantized by the browser and only keeps the scrollbar
-   * in sync; the override + direct setViewport carry the sub-pixel position,
-   * so rows glide instead of stepping one DOM-pixel's worth of rows at a
-   * time under high compression.
-   */
-  private applySyntheticScrollTop;
-  /**
-   * Decide whether a fast fling must fall back to throttled rendering.
-   * The default is a full pipeline run every frame — a reduced cadence at
-   * low speed reads as rows locking and snapping. Only when the measured
-   * frame pace shows the device cannot sustain per-frame renders does the
-   * fling latch onto the throttled cadence, and it stays latched until the
-   * fling slows below the row-flux threshold so the cadence never
-   * oscillates.
-   */
-  private updateFlingThrottle;
-  private isFlingPipelineDue;
-  /** Hand scroll-position ownership back to native scroll events. */
-  private releaseScrollOverride;
+  private resolveContext;
   private readonly onWheel;
   private readonly onTouchStart;
-  private readonly startTouchGesture;
+  private startTouchGesture;
   private attachGestureListeners;
   private clearGesture;
-  private findTrackedTouch;
+  /** Drop the gesture and hand scrolling back to the browser. */
+  private abandonGesture;
+  private trackedTouch;
   private readonly onTouchMove;
-  /**
-   * True when the scroll position no longer matches what this controller
-   * wrote: a native scroller is moving the element between our frames. Our
-   * own writes only diverge by browser rounding, well under the threshold.
-   */
-  private hasNativeScrollTakenOver;
   private scheduleDragApply;
   private flushPendingDrag;
+  /**
+   * Render a drag position. While the finger is down the workload is
+   * self-limiting (content moves at most one screen per gesture), so every
+   * coalesced frame runs the full pipeline — throttling under the finger
+   * reads as jank, not speed.
+   */
+  private applyDragTarget;
   private readonly onTouchEnd;
   private readonly onTouchCancel;
-  private startFling;
 }
 //#endregion
 //#region src/adapter/batch-applier.d.ts
@@ -3370,4 +2504,4 @@ declare class InputEventAdapter<TData = unknown> {
   private dispatchCellDragStart;
 }
 //#endregion
-export { type AssignSlotInstruction, AutoScrollDriver, type BatchChangeSetters, type BatchInstructionListener, type CalculateFillHandlePositionParams, type CancelColumnMoveInstruction, type CancelColumnResizeInstruction, type CancelFillInstruction, type CancelRowDragInstruction, type CellDataType, type CellPointerAction, type CellPosition, type CellRange, type CellRendererParams, type CellValue, type CellValueChangedEvent, type CloseFilterPopupInstruction, type ColumnDefinition, type ColumnFilterModel, type ColumnMoveDragState, type ColumnResizeDragState, type ColumnScrollGeometry, type ColumnsChangedInstruction, type CommitColumnMoveInstruction, type CommitColumnResizeInstruction, type CommitEditInstruction, type CommitFillInstruction, type CommitRowDragInstruction, type ContainerBounds, type CreateSlotInstruction, type DataChangeListener, type DataErrorInstruction, type DataLoadedInstruction, type DataLoadingInstruction, type DataSource, type DataSourceLoadMode, DataSourceOwner, type DataSourceRange, type DataSourceRequest, type DataSourceResponse, type DateFilterCondition, type DateFilterOperator, type DestroySlotInstruction, type Direction, type DistinctValueEntry, type DragEndResult, type DragMoveResult, type DragState, EditManager, type EditManagerOptions, type EditRendererParams, type EditState, type FillHandlePosition, type FillHandleState, FillManager, type FillPointerAction, type FilterCombination, type FilterCondition, type FilterModel, type FilterOperatorOption, type FilterPopupState, GridCore, type GridCoreOptions, type GridFilterOperatorLabels, type GridInstruction, type GridLabels, type GridState, type HeaderData, type HeaderRendererParams, type HighlightContext, HighlightManager, type HighlightingOptions, IndexedDataStore, type IndexedDataStoreOptions, type InitialStateArgs, InputEventAdapter, type InputEventAdapterDeps, InputHandler, type InputHandlerDeps, type InputResult, type InstructionListener, type KeyEventData, type KeyboardResult, type MoveSlotInstruction, type MultiColumnSortedChunk, type MutableClientDataSourceOptions, type MutableDataSource, type NumberFilterCondition, type NumberFilterOperator, type OpenFilterPopupInstruction, ParallelSortManager, type ParallelSortOptions, PendingCellTapController, type PendingCellTapDeps, PendingRowDragController, type PendingRowDragDeps, type PointerEventData, type PopupPosition, ROW_DRAG_HOLD_MS, type RowCacheEviction, type RowCacheOptions, RowDataManager, type RowDataManagerOptions, type RowDragState, type RowId, type RowLoadingMode, type RowLoadingOptions, RowMutationManager, type RowMutationManagerOptions, type RowSortCache, type RowsAddedInstruction, type RowsRemovedInstruction, type RowsUpdatedInstruction, ScrollVirtualizationManager, type ScrollVirtualizationManagerOptions, SelectionManager, type SelectionState, type ServerDataSourceOptions, type SetActiveCellInstruction, type SetContentSizeInstruction, type SetHoverPositionInstruction, type SetSelectionRangeInstruction, type SlotData, type BatchInstructionListener$1 as SlotPoolBatchListener, SlotPoolManager, type SlotPoolManagerOptions, type SlotState, type SortDirection, SortFilterManager, type SortFilterManagerOptions, type SortModel, type SortedChunk, type StartColumnMoveInstruction, type StartColumnResizeInstruction, type StartEditInstruction, type StartFillInstruction, type StartPeekInstruction, type StartRowDragInstruction, type StopEditInstruction, type StopPeekInstruction, TAP_SLOP_PX, type TextFilterCondition, type TextFilterOperator, TouchScrollController, type TouchScrollDeps, type Transaction, TransactionManager, type TransactionManagerOptions, type TransactionProcessedInstruction, type TransactionResult, type UpdateColumnMoveInstruction, type UpdateColumnResizeInstruction, type UpdateFillInstruction, type UpdateHeaderInstruction, type UpdateRowDragInstruction, type VisibleColumnInfo, WorkerPool, type WorkerPoolOptions, applyBatchInstructions, applyInstruction, bindPeekSelectAll, buildCellClasses, calculateColumnPositions, calculateFillHandlePosition, calculateFilterPopupPosition, calculateScaledColumnPositions, compareValues, computeValueHash, createClientDataSource, createDataSourceFromArray, createInitialState, createMutableClientDataSource, createServerDataSource, defaultGridLabels, detectBoundaryCollisions, evaluateColumnFilter, evaluateDateCondition, evaluateNumberCondition, evaluateTextCondition, findColumnAtX, findSlotForRow, formatCellValue, formatLabel, getDateOperatorOptions, getFieldValue, getNumberOperatorOptions, getTextOperatorOptions, getTotalWidth, groupDistinctValues, isBlankCellValue, isCellActive, isCellEditing, isCellInFillPreview, isCellSelected, isColumnInSelectionRange, isRowInSelectionRange, isRowVisible, isSameDay, kWayMerge, kWayMergeMultiColumn, labelsForSelectedValues, rawValueKey, rawValuesForLabels, resolveGridLabels, rowPassesFilter, scrollCellIntoView, setFieldValue, stringToSortableNumber, toPointerEventData };
+export { type AssignSlotInstruction, AutoScrollDriver, type BatchChangeSetters, type BatchInstructionListener, type CalculateFillHandlePositionParams, type CancelFillInstruction, type CellDataType, type CellPointerAction, type CellPosition, type CellRange, type CellRendererParams, type CellValue, type CellValueChangedEvent, type CloseFilterPopupInstruction, type ColumnDefinition, type ColumnFilterInput, type ColumnFilterModel, type ColumnMoveDragState, type ColumnResizeDragState, type ColumnScrollGeometry, type ColumnsChangedInstruction, type CommitEditInstruction, type CommitFillInstruction, type ContainerBounds, type CreateSlotInstruction, type DataChangeListener, type DataErrorInstruction, type DataLoadedInstruction, type DataLoadingInstruction, type DataSource, type DataSourceLoadMode, DataSourceOwner, type DataSourceRange, type DataSourceRequest, type DataSourceResponse, type DateFilterCondition, type DateFilterOperator, type DestroySlotInstruction, type Direction, type DistinctValueEntry, type DragEndResult, type DragMoveResult, type DragState, type EditRendererParams, type EditState, type FillHandlePosition, type FillHandleState, type FillPointerAction, type FilterCombination, type FilterCondition, type FilterConditionGroup, type FilterModel, type FilterOperatorOption, type FilterPopupState, GridCore, type GridCoreOptions, type GridFilterOperatorLabels, type GridInstruction, type GridLabelOverrides, type GridLabels, type GridState, type HeaderData, type HeaderRendererParams, type HighlightContext, type HighlightingOptions, IndexedDataStore, type IndexedDataStoreOptions, type InitialStateArgs, InputEventAdapter, type InputEventAdapterDeps, InputHandler, type InputHandlerDeps, type InputResult, type InstructionListener, type KeyEventData, type KeyboardResult, type LegacyColumnFilterModel, type LegacyFilterCondition, type MoveSlotInstruction, type MutableClientDataSourceOptions, type MutableDataSource, type NumberFilterCondition, type NumberFilterOperator, type OpenFilterPopupInstruction, type ParallelSortOptions, PendingCellTapController, type PendingCellTapDeps, PendingRowDragController, type PendingRowDragDeps, type PointerEventData, type PopupPosition, ROW_DRAG_HOLD_MS, type RowCacheEviction, type RowCacheOptions, type RowDragState, type RowId, type RowLoadingMode, type RowLoadingOptions, type SelectionState, type ServerDataSourceOptions, type SetActiveCellInstruction, type SetContentSizeInstruction, type SetHoverPositionInstruction, type SetSelectionRangeInstruction, type SlotData, type SlotState, type SortDirection, type SortModel, type StartEditInstruction, type StartFillInstruction, type StartPeekInstruction, type StopEditInstruction, type StopPeekInstruction, TAP_SLOP_PX, type TextFilterCondition, type TextFilterOperator, TouchScrollController, type TouchScrollDeps, type Transaction, TransactionManager, type TransactionManagerOptions, type TransactionResult, type UpdateFillInstruction, type UpdateHeaderInstruction, type VisibleColumnInfo, applyBatchInstructions, applyInstruction, bindPeekSelectAll, buildCellClasses, calculateColumnPositions, calculateFillHandlePosition, calculateFilterPopupPosition, calculateScaledColumnPositions, createClientDataSource, createDataSourceFromArray, createInitialState, createMutableClientDataSource, createServerDataSource, defaultGridLabels, evaluateColumnFilter, evaluateDateCondition, evaluateNumberCondition, evaluateTextCondition, findColumnAtX, formatCellValue, formatLabel, getDateOperatorOptions, getFieldValue, getNumberOperatorOptions, getTextOperatorOptions, getTotalWidth, groupDistinctValues, isBlankCellValue, isCellActive, isCellEditing, isCellInFillPreview, isCellSelected, isLegacyColumnFilterModel, isRowVisible, isSameDay, labelsForSelectedValues, normalizeColumnFilterModel, rawValueKey, rawValuesForLabels, resolveGridLabels, rowPassesFilter, scrollCellIntoView, setFieldValue, toPointerEventData };