@gp-grid/vue 0.7.4 → 0.8.1

package/dist/index.d.ts

@@ -1,1419 +1,24 @@
-import * as vue0 from "vue";
-import { Component, ComputedRef, Ref, ShallowRef, VNode } from "vue";
+import * as vue from "vue";
+import { Component as Component$1, ComputedRef, Ref, ShallowRef, VNode } from "vue";
+import * as _gp_grid_core0 from "@gp-grid/core";
+import { CellDataType, CellPosition, CellPosition as CellPosition$1, CellRange, CellRange as CellRange$1, CellRendererParams, CellRendererParams as CellRendererParams$1, CellValue, CellValue as CellValue$1, CellValueChangedEvent, CellValueChangedEvent as CellValueChangedEvent$1, ColumnDefinition, ColumnDefinition as ColumnDefinition$1, ColumnFilterModel, ColumnFilterModel as ColumnFilterModel$1, ContainerBounds, DataSource, DataSource as DataSource$1, DataSourceRequest, DataSourceResponse, DateFilterCondition, DragState, DragState as DragState$1, EditRendererParams, EditRendererParams as EditRendererParams$1, FilterCondition, FilterModel, FilterPopupState, GridCore, GridCore as GridCore$1, GridInstruction, GridInstruction as GridInstruction$1, GridState, GridState as GridState$1, HeaderData, HeaderData as HeaderData$1, HeaderRendererParams, HeaderRendererParams as HeaderRendererParams$1, HighlightingOptions, KeyEventData, MutableDataSource, MutableDataSource as MutableDataSource$1, NumberFilterCondition, ParallelSortOptions, PointerEventData, Row, Row as Row$1, RowId, RowId as RowId$1, SelectionState, SlotData, SlotData as SlotData$1, SortDirection, SortDirection as SortDirection$1, SortModel, TextFilterCondition, buildCellClasses, buildCellClasses as buildCellClasses$1, calculateColumnPositions, createClientDataSource, createDataSourceFromArray, createMutableClientDataSource, createServerDataSource, findColumnAtX, getTotalWidth, gridStyles, injectStyles, isCellActive, isCellActive as isCellActive$1, isCellEditing, isCellEditing as isCellEditing$1, isCellInFillPreview, isCellInFillPreview as isCellInFillPreview$1, isCellSelected, isCellSelected as isCellSelected$1, isRowVisible } from "@gp-grid/core";
 
-//#region ../core/src/types/basic.d.ts
-/** Cell data type primitive types */
-type CellDataType = "text" | "number" | "boolean" | "date" | "dateString" | "dateTime" | "dateTimeString" | "object";
-/** Cell value type */
-type CellValue = string | number | boolean | Date | object | null;
-/** Row type */
-type Row = unknown;
-/** Row ID type for transaction operations */
-type RowId = string | number;
-/** Sort direction type */
-type SortDirection = "asc" | "desc";
-/** Sort model type */
-type SortModel = {
-  colId: string;
-  direction: SortDirection;
-};
-/** Cell position */
-interface CellPosition {
-  row: number;
-  col: number;
-}
-/** Cell range */
-interface CellRange {
-  startRow: number;
-  startCol: number;
-  endRow: number;
-  endCol: number;
-}
-/** Selection state */
-interface SelectionState {
-  /** Active cell position */
-  activeCell: CellPosition | null;
-  /** Selection range */
-  range: CellRange | null;
-  /** Anchor cell for shift-extend selection */
-  anchor: CellPosition | null;
-  /** Whether selection mode is active (ctrl held) */
-  selectionMode: boolean;
-}
-/** Edit state */
-interface EditState {
-  /** Row index */
-  row: number;
-  /** Column index */
-  col: number;
-  /** Initial value */
-  initialValue: CellValue;
-  /** Current value */
-  currentValue: CellValue;
-}
-/** Fill handle state */
-interface FillHandleState {
-  /** Source range */
-  sourceRange: CellRange;
-  /** Target row */
-  targetRow: number;
-  /** Target column */
-  targetCol: number;
-}
-//#endregion
-//#region ../core/src/types/highlighting.d.ts
-/**
- * Minimal column info for highlighting context.
- * Uses structural typing to avoid circular dependency with columns.ts.
- */
-interface HighlightColumnInfo {
-  field: string;
-  colId?: string;
-}
-/**
- * Unified context for row, column, and cell highlighting.
- *
- * - Row context: `rowIndex` is set, `colIndex` is null
- * - Column context: `colIndex` is set, `rowIndex` is null
- * - Cell context: both `rowIndex` and `colIndex` are set
- */
-interface HighlightContext<TData = Record<string, unknown>> {
-  /** Row index. Null for column-only context. */
-  rowIndex: number | null;
-  /** Column index. Null for row-only context. */
-  colIndex: number | null;
-  /** Column definition. Present for column and cell contexts. */
-  column?: HighlightColumnInfo;
-  /** Row data. Present for row and cell contexts. */
-  rowData?: TData;
-  /** Currently hovered cell position, null if not hovering */
-  hoverPosition: CellPosition | null;
-  /** Currently active (focused) cell position */
-  activeCell: CellPosition | null;
-  /** Current selection range */
-  selectionRange: CellRange | null;
-  /** Whether this row/column/cell is hovered (respects hoverScope) */
-  isHovered: boolean;
-  /** Whether this row/column contains or is the active cell */
-  isActive: boolean;
-  /** Whether this row/column/cell overlaps or is in the selection range */
-  isSelected: boolean;
-}
-/**
- * Grid-level highlighting options.
- * Hover tracking is automatically enabled when any highlighting callback is defined.
- * Each callback type has its own natural interpretation of `isHovered`:
- * - computeRowClasses: isHovered = mouse is on any cell in this row
- * - computeColumnClasses: isHovered = mouse is on any cell in this column
- * - computeCellClasses: isHovered = mouse is on this exact cell
- *
- * For a crosshair effect, implement both computeRowClasses and computeColumnClasses.
- */
-interface HighlightingOptions<TData = Record<string, unknown>> {
-  /**
-   * Row-level class callback.
-   * Classes returned are applied to the row container element.
-   * Context has `rowIndex` set, `colIndex` is null.
-   * `isHovered` is true when the mouse is on any cell in this row.
-   * @returns Array of CSS class names
-   */
-  computeRowClasses?: (context: HighlightContext<TData>) => string[];
-  /**
-   * Column-level class callback.
-   * Classes returned are applied to all cells in that column (not header).
-   * Context has `colIndex` set, `rowIndex` is null.
-   * `isHovered` is true when the mouse is on any cell in this column.
-   * @returns Array of CSS class names
-   */
-  computeColumnClasses?: (context: HighlightContext<TData>) => string[];
-  /**
-   * Cell-level class callback.
-   * Classes returned are applied to individual cells for fine-grained control.
-   * Context has both `rowIndex` and `colIndex` set.
-   * `isHovered` is true only when the mouse is on this exact cell.
-   * @returns Array of CSS class names
-   */
-  computeCellClasses?: (context: HighlightContext<TData>) => string[];
-}
-//#endregion
-//#region ../core/src/types/columns.d.ts
-/** Column definition */
-interface ColumnDefinition {
-  field: string;
-  colId?: string;
-  cellDataType: CellDataType;
-  width: number;
-  headerName?: string;
-  editable?: boolean;
-  /** Whether column is sortable. Default: true when sortingEnabled */
-  sortable?: boolean;
-  /** Whether column is filterable. Default: true */
-  filterable?: boolean;
-  /** Whether column is hidden. Hidden columns are not rendered but still exist in the definition. Default: false */
-  hidden?: boolean;
-  /** Renderer key for adapter lookup, or inline renderer function */
-  cellRenderer?: string;
-  editRenderer?: string;
-  headerRenderer?: string;
-  /**
-   * Per-column override for column-level highlighting.
-   * If defined, overrides grid-level computeColumnClasses for this column.
-   * Context has `colIndex` set, `rowIndex` is null.
-   * @returns Array of CSS class names to apply to all cells in this column
-   */
-  computeColumnClasses?: (context: HighlightContext) => string[];
-  /**
-   * Per-column override for cell-level highlighting.
-   * If defined, overrides grid-level computeCellClasses for cells in this column.
-   * Context has both `rowIndex` and `colIndex` set.
-   * @returns Array of CSS class names to apply to individual cells
-   */
-  computeCellClasses?: (context: HighlightContext) => string[];
-}
-//#endregion
-//#region ../core/src/types/filters.d.ts
-/** Text filter operators */
-type TextFilterOperator = "contains" | "notContains" | "equals" | "notEquals" | "startsWith" | "endsWith" | "blank" | "notBlank";
-/** Number filter operators (symbols for display) */
-type NumberFilterOperator = "=" | "!=" | ">" | "<" | ">=" | "<=" | "between" | "blank" | "notBlank";
-/** Date filter operators */
-type DateFilterOperator = "=" | "!=" | ">" | "<" | "between" | "blank" | "notBlank";
-/** Filter combination mode */
-type FilterCombination = "and" | "or";
-/** Text filter condition */
-interface TextFilterCondition {
-  type: "text";
-  operator: TextFilterOperator;
-  value?: string;
-  /** Selected distinct values for checkbox-style filtering */
-  selectedValues?: Set<string>;
-  /** Include blank values */
-  includeBlank?: boolean;
-  /** Operator connecting this condition to the next. Defaults to ColumnFilterModel.combination */
-  nextOperator?: FilterCombination;
-}
-/** Number filter condition */
-interface NumberFilterCondition {
-  type: "number";
-  operator: NumberFilterOperator;
-  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 {
-  type: "date";
-  operator: DateFilterOperator;
-  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 {
-  conditions: FilterCondition[];
-  combination: FilterCombination;
-}
-/** Filter model type - maps column ID to filter */
-type FilterModel = Record<string, ColumnFilterModel>;
-//#endregion
-//#region ../core/src/types/data-source.d.ts
-/** Data source request */
-interface DataSourceRequest {
-  /** Pagination */
-  pagination: {
-    /** Page index */
-    pageIndex: number;
-    /** Page size */
-    pageSize: number;
-  };
-  /** Sort */
-  sort?: SortModel[];
-  /** Filter */
-  filter?: FilterModel;
-}
-/** Data source response */
-interface DataSourceResponse<TData = Row> {
-  /** Rows */
-  rows: TData[];
-  /** Total rows */
-  totalRows: number;
-}
-/** Data source interface */
-interface DataSource<TData = Row> {
-  fetch(request: DataSourceRequest): Promise<DataSourceResponse<TData>>;
-  /** Optional cleanup method to release resources */
-  destroy?: () => void;
-}
-//#endregion
-//#region ../core/src/types/instructions.d.ts
-/** Create slot instruction */
-interface CreateSlotInstruction {
-  type: "CREATE_SLOT";
-  slotId: string;
-}
-/** Destroy slot instruction */
-interface DestroySlotInstruction {
-  type: "DESTROY_SLOT";
-  slotId: string;
-}
-/** Assign slot instruction */
-interface AssignSlotInstruction {
-  type: "ASSIGN_SLOT";
-  slotId: string;
-  rowIndex: number;
-  rowData: Row;
-}
-/** Move slot instruction */
-interface MoveSlotInstruction {
-  type: "MOVE_SLOT";
-  slotId: string;
-  translateY: number;
-}
-/** Set active cell instruction */
-interface SetActiveCellInstruction {
-  type: "SET_ACTIVE_CELL";
-  position: CellPosition | null;
-}
-/** Set hover position instruction (for highlighting) */
-interface SetHoverPositionInstruction {
-  type: "SET_HOVER_POSITION";
-  position: CellPosition | null;
-}
-/** Set selection range instruction */
-interface SetSelectionRangeInstruction {
-  type: "SET_SELECTION_RANGE";
-  range: CellRange | null;
-}
-/** Update visible range instruction - emitted when selection moves outside visible viewport */
-interface UpdateVisibleRangeInstruction {
-  type: "UPDATE_VISIBLE_RANGE";
-  start: number;
-  end: number;
-}
-/** Start edit instruction */
-interface StartEditInstruction {
-  type: "START_EDIT";
-  row: number;
-  col: number;
-  initialValue: CellValue;
-}
-/** Stop edit instruction */
-interface StopEditInstruction {
-  type: "STOP_EDIT";
-}
-/** Commit edit instruction */
-interface CommitEditInstruction {
-  type: "COMMIT_EDIT";
-  row: number;
-  col: number;
-  value: CellValue;
-}
-/** Set content size instruction */
-interface SetContentSizeInstruction {
-  type: "SET_CONTENT_SIZE";
-  width: number;
-  height: number;
-  viewportWidth: number;
-}
-/** Update header instruction */
-interface UpdateHeaderInstruction {
-  type: "UPDATE_HEADER";
-  colIndex: number;
-  column: ColumnDefinition;
-  sortDirection?: SortDirection;
-  sortIndex?: number;
-  /** Whether column is sortable */
-  sortable: boolean;
-  /** Whether column is filterable */
-  filterable: boolean;
-  /** Whether column has an active filter */
-  hasFilter: boolean;
-}
-/** Open filter popup instruction */
-interface OpenFilterPopupInstruction {
-  type: "OPEN_FILTER_POPUP";
-  colIndex: number;
-  column: ColumnDefinition;
-  anchorRect: {
-    top: number;
-    left: number;
-    width: number;
-    height: number;
-  };
-  distinctValues: CellValue[];
-  currentFilter?: ColumnFilterModel;
-}
-/** Close filter popup instruction */
-interface CloseFilterPopupInstruction {
-  type: "CLOSE_FILTER_POPUP";
-}
-/** Start fill instruction */
-interface StartFillInstruction {
-  type: "START_FILL";
-  sourceRange: CellRange;
-}
-/** Update fill instruction */
-interface UpdateFillInstruction {
-  type: "UPDATE_FILL";
-  targetRow: number;
-  targetCol: number;
-}
-/** Commit fill instruction */
-interface CommitFillInstruction {
-  type: "COMMIT_FILL";
-  filledCells: Array<{
-    row: number;
-    col: number;
-    value: CellValue;
-  }>;
-}
-/** Cancel fill instruction */
-interface CancelFillInstruction {
-  type: "CANCEL_FILL";
-}
-/** Data loading instruction */
-interface DataLoadingInstruction {
-  type: "DATA_LOADING";
-}
-/** Data loaded instruction */
-interface DataLoadedInstruction {
-  type: "DATA_LOADED";
-  totalRows: number;
-}
-/** Data error instruction */
-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;
-}
-/** Union type of all instructions */
-type GridInstruction = /** Slot lifecycle */
-CreateSlotInstruction | DestroySlotInstruction | AssignSlotInstruction | MoveSlotInstruction
-/** Selection */ | SetActiveCellInstruction | SetSelectionRangeInstruction | UpdateVisibleRangeInstruction
-/** Highlighting */ | SetHoverPositionInstruction
-/** Editing */ | StartEditInstruction | StopEditInstruction | CommitEditInstruction
-/** Layout */ | SetContentSizeInstruction | UpdateHeaderInstruction
-/** Filter popup */ | OpenFilterPopupInstruction | CloseFilterPopupInstruction
-/** Fill handle */ | StartFillInstruction | UpdateFillInstruction | CommitFillInstruction | CancelFillInstruction
-/** Data */ | DataLoadingInstruction | DataLoadedInstruction | DataErrorInstruction
-/** Transactions */ | RowsAddedInstruction | RowsRemovedInstruction | RowsUpdatedInstruction | TransactionProcessedInstruction;
-/** Instruction listener: Single instruction Listener that receives a single instruction, used by frameworks to update their state */
-type InstructionListener = (instruction: GridInstruction) => void;
-//#endregion
-//#region ../core/src/types/renderers.d.ts
-/** Cell renderer params */
-interface CellRendererParams<TData extends Row = Row> {
-  /** Cell value */
-  value: CellValue;
-  /** Row data */
-  rowData: TData;
-  /** Column definition */
-  column: ColumnDefinition;
-  /** Row index */
-  rowIndex: number;
-  /** Column index */
-  colIndex: number;
-  /** Is active cell */
-  isActive: boolean;
-  /** Is selected cell */
-  isSelected: boolean;
-  /** Is editing cell */
-  isEditing: boolean;
-}
-/** Edit renderer params */
-interface EditRendererParams<TData extends Row = Row> extends CellRendererParams<TData> {
-  /** Initial value */
-  initialValue: CellValue;
-  /** On value change */
-  onValueChange: (newValue: CellValue) => void;
-  /** On commit */
-  onCommit: () => void;
-  /** On cancel */
-  onCancel: () => void;
-}
-/** Header renderer params */
-interface HeaderRendererParams {
-  /** Column definition */
-  column: ColumnDefinition;
-  /** Column index */
-  colIndex: number;
-  /** Sort direction */
-  sortDirection?: SortDirection;
-  /** Sort index */
-  sortIndex?: number;
-  /** Whether column is sortable */
-  sortable: boolean;
-  /** Whether column is filterable */
-  filterable: boolean;
-  /** Whether column has an active filter */
-  hasFilter: boolean;
-  /** On sort */
-  onSort: (direction: SortDirection | null, addToExisting: boolean) => void;
-  /** On filter click */
-  onFilterClick: () => void;
-}
-//#endregion
-//#region ../core/src/types/options.d.ts
-/** Grid core options */
-interface GridCoreOptions<TData = Row> {
-  /** Column definitions */
-  columns: ColumnDefinition[];
-  /** Data source */
-  dataSource: DataSource<TData>;
-  /** Row height */
-  rowHeight: number;
-  /** Header height: Default to row height */
-  headerHeight?: number;
-  /** Overscan: How many rows to render outside the viewport */
-  overscan?: number;
-  /** 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 */
-  highlighting?: HighlightingOptions<TData>;
-}
-//#endregion
-//#region ../core/src/types/input.d.ts
-/** Framework-agnostic pointer/mouse event data */
-interface PointerEventData {
-  /** X coordinate relative to viewport */
-  clientX: number;
-  /** Y coordinate relative to viewport */
-  clientY: number;
-  /** Mouse button (0 = left, 1 = middle, 2 = right) */
-  button: number;
-  /** Whether Shift key is pressed */
-  shiftKey: boolean;
-  /** Whether Ctrl key is pressed */
-  ctrlKey: boolean;
-  /** Whether Meta/Command key is pressed */
-  metaKey: boolean;
-}
-/** Framework-agnostic keyboard event data */
-interface KeyEventData {
-  /** Key value (e.g., 'Enter', 'ArrowUp', 'a') */
-  key: string;
-  /** Whether Shift key is pressed */
-  shiftKey: boolean;
-  /** Whether Ctrl key is pressed */
-  ctrlKey: boolean;
-  /** Whether Meta/Command key is pressed */
-  metaKey: boolean;
-}
-/** Container bounds and scroll position */
-interface ContainerBounds {
-  /** Top position relative to viewport */
-  top: number;
-  /** Left position relative to viewport */
-  left: number;
-  /** Container width */
-  width: number;
-  /** Container height */
-  height: number;
-  /** Current scroll top position */
-  scrollTop: number;
-  /** Current scroll left position */
-  scrollLeft: number;
-}
-/** Result from mouse/pointer input handlers */
-interface InputResult {
-  /** Whether to call preventDefault() on the event */
-  preventDefault: boolean;
-  /** Whether to call stopPropagation() on the event */
-  stopPropagation: boolean;
-  /** Whether framework should focus the container element */
-  focusContainer?: boolean;
-  /** Type of drag operation to start (framework manages global listeners) */
-  startDrag?: "selection" | "fill";
-}
-/** Result from keyboard input handler */
-interface KeyboardResult {
-  /** Whether to call preventDefault() on the event */
-  preventDefault: boolean;
-  /** Cell to scroll into view (if navigation occurred) */
-  scrollToCell?: CellPosition;
-}
-/** Result from drag move handler */
-interface DragMoveResult {
-  /** Target row index */
-  targetRow: number;
-  /** Target column index */
-  targetCol: number;
-  /** Auto-scroll deltas (null if no auto-scroll needed) */
-  autoScroll: {
-    dx: number;
-    dy: number;
-  } | null;
-}
-/** Options for InputHandler constructor */
-interface InputHandlerDeps {
-  /** Get header height */
-  getHeaderHeight: () => number;
-  /** Get row height */
-  getRowHeight: () => number;
-  /** Get column positions array (indexed by visible column) */
-  getColumnPositions: () => number[];
-  /** Get visible column count */
-  getColumnCount: () => number;
-  /**
-   * Convert visible column index to original column index.
-   * Used when columns can be hidden. Returns the original index for selection tracking.
-   * If not provided, visible index is used directly (no hidden columns).
-   */
-  getOriginalColumnIndex?: (visibleIndex: number) => number;
-}
-/** Current drag state for UI rendering */
-interface DragState {
-  /** Whether any drag operation is active */
-  isDragging: boolean;
-  /** Type of active drag operation */
-  dragType: "selection" | "fill" | null;
-  /** Source range for fill operations */
-  fillSourceRange: CellRange | null;
-  /** Current fill target position */
-  fillTarget: {
-    row: number;
-    col: number;
-  } | null;
-}
-//#endregion
-//#region ../core/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;
-/**
- * Find column index at a given X coordinate
- */
-declare const findColumnAtX: (x: number, columnPositions: number[]) => number;
-//#endregion
-//#region ../core/src/utils/classNames.d.ts
-/**
- * Check if a cell is within the selection range
- */
-declare const isCellSelected: (row: number, col: number, selectionRange: CellRange | null) => boolean;
-/**
- * Check if a cell is the active cell
- */
-declare const isCellActive: (row: number, col: number, activeCell: CellPosition | null) => boolean;
-/**
- * Check if a row is within the visible range (not in overscan)
- */
-declare const isRowVisible: (row: number, visibleRowRange: {
-  start: number;
-  end: number;
-} | null) => boolean;
-/**
- * Check if a cell is being edited
- */
-declare const isCellEditing: (row: number, col: number, editingCell: {
-  row: number;
-  col: number;
-} | null) => boolean;
-/**
- * Check if a cell is in the fill preview range (vertical-only fill)
- */
-declare const isCellInFillPreview: (row: number, col: number, isDraggingFill: boolean, fillSourceRange: CellRange | null, fillTarget: {
-  row: number;
-  col: number;
-} | null) => boolean;
-/**
- * Build cell CSS classes based on state
- */
-declare const buildCellClasses: (isActive: boolean, isSelected: boolean, isEditing: boolean, inFillPreview: boolean) => string;
-//#endregion
-//#region ../core/src/utils/event-emitter.d.ts
-/**
- * Batch instruction listener for efficient state updates
- */
-type BatchInstructionListener = (instructions: GridInstruction[]) => void;
-//#endregion
-//#region ../core/src/selection.d.ts
-type Direction = "up" | "down" | "left" | "right";
-interface SelectionManagerOptions {
-  getRowCount: () => number;
-  getColumnCount: () => number;
-  getCellValue: (row: number, col: number) => CellValue;
-  getRowData: (row: number) => Row | undefined;
-  getColumn: (col: number) => ColumnDefinition | undefined;
-}
-/**
- * Manages Excel-style cell selection, keyboard navigation, and clipboard operations.
- */
-declare class SelectionManager {
-  private state;
-  private options;
-  private emitter;
-  onInstruction: (listener: InstructionListener) => () => void;
-  private emit;
-  constructor(options: SelectionManagerOptions);
-  getState(): SelectionState;
-  getActiveCell(): CellPosition | null;
-  getSelectionRange(): CellRange | null;
-  isSelected(row: number, col: number): boolean;
-  isActiveCell(row: number, col: number): boolean;
-  /**
-   * Start a selection at the given cell.
-   * @param cell - The cell to select
-   * @param opts.shift - Extend selection from anchor (range select)
-   * @param opts.ctrl - Toggle selection mode
-   */
-  startSelection(cell: CellPosition, opts?: {
-    shift?: boolean;
-    ctrl?: boolean;
-  }): void;
-  /**
-   * Move focus in a direction, optionally extending the selection.
-   */
-  moveFocus(direction: Direction, extend?: boolean): void;
-  /**
-   * Select all cells in the grid (Ctrl+A).
-   */
-  selectAll(): void;
-  /**
-   * Clear the current selection.
-   */
-  clearSelection(): void;
-  /**
-   * Set the active cell directly.
-   */
-  setActiveCell(row: number, col: number): void;
-  /**
-   * Set the selection range directly.
-   */
-  setSelectionRange(range: CellRange): void;
-  /**
-   * Get the data from the currently selected cells as a 2D array.
-   */
-  getSelectedData(): CellValue[][];
-  /**
-   * Copy the selected data to the clipboard (Ctrl+C).
-   */
-  copySelectionToClipboard(): Promise<void>;
-  /**
-   * Clean up resources for garbage collection.
-   */
-  destroy(): void;
-  private clampPosition;
-}
-//#endregion
-//#region ../core/src/fill.d.ts
-interface FillManagerOptions {
-  getRowCount: () => number;
-  getColumnCount: () => number;
-  getCellValue: (row: number, col: number) => CellValue;
-  getColumn: (col: number) => ColumnDefinition | undefined;
-  setCellValue: (row: number, col: number, value: CellValue) => void;
-}
-/**
- * Manages fill handle operations including pattern detection and auto-fill.
- */
-declare class FillManager {
-  private state;
-  private options;
-  private emitter;
-  onInstruction: (listener: InstructionListener) => () => void;
-  private emit;
-  constructor(options: FillManagerOptions);
-  getState(): FillHandleState | null;
-  isActive(): boolean;
-  /**
-   * Start a fill drag operation from a source range.
-   */
-  startFillDrag(sourceRange: CellRange): void;
-  /**
-   * Update the fill drag target position.
-   */
-  updateFillDrag(targetRow: number, targetCol: number): void;
-  /**
-   * Commit the fill operation - apply pattern to target cells.
-   */
-  commitFillDrag(): void;
-  /**
-   * Cancel the fill operation.
-   */
-  cancelFillDrag(): void;
-  /**
-   * Clean up resources for garbage collection.
-   */
-  destroy(): void;
-  /**
-   * Calculate the values to fill based on source pattern.
-   */
-  private calculateFilledCells;
-  private getSourceColumnValues;
-  private detectPattern;
-  private applyPattern;
-}
-//#endregion
-//#region ../core/src/input-handler.d.ts
-declare class InputHandler<TData extends Row = Row> {
-  private core;
-  private deps;
-  private isDraggingSelection;
-  private isDraggingFill;
-  private fillSourceRange;
-  private fillTarget;
-  constructor(core: GridCore<TData>, deps: InputHandlerDeps);
-  /**
-   * Update dependencies (called when options change)
-   */
-  updateDeps(deps: Partial<InputHandlerDeps>): void;
-  /**
-   * Get current drag state for UI rendering
-   */
-  getDragState(): DragState;
-  /**
-   * Handle cell mouse down event
-   */
-  handleCellMouseDown(rowIndex: number, colIndex: number, event: PointerEventData): InputResult;
-  /**
-   * Handle cell double click event (start editing)
-   */
-  handleCellDoubleClick(rowIndex: number, colIndex: number): void;
-  /**
-   * Handle cell mouse enter event (for hover highlighting)
-   */
-  handleCellMouseEnter(rowIndex: number, colIndex: number): void;
-  /**
-   * Handle cell mouse leave event (for hover highlighting)
-   */
-  handleCellMouseLeave(): void;
-  /**
-   * Handle fill handle mouse down event
-   */
-  handleFillHandleMouseDown(activeCell: CellPosition | null, selectionRange: CellRange | null, _event: PointerEventData): InputResult;
-  /**
-   * Handle header click event (cycle sort direction)
-   */
-  handleHeaderClick(colId: string, addToExisting: boolean): void;
-  /**
-   * Start selection drag (called by framework after handleCellMouseDown returns startDrag: 'selection')
-   */
-  startSelectionDrag(): void;
-  /**
-   * Handle drag move event (selection or fill)
-   */
-  handleDragMove(event: PointerEventData, bounds: ContainerBounds): DragMoveResult | null;
-  /**
-   * Handle drag end event
-   */
-  handleDragEnd(): void;
-  /**
-   * Handle wheel event with dampening for large datasets
-   * Returns scroll deltas or null if no dampening needed
-   */
-  handleWheel(deltaY: number, deltaX: number, dampening: number): {
-    dy: number;
-    dx: number;
-  } | null;
-  /**
-   * Handle keyboard event
-   */
-  handleKeyDown(event: KeyEventData, activeCell: CellPosition | null, editingCell: {
-    row: number;
-    col: number;
-  } | null, filterPopupOpen: boolean): KeyboardResult;
-  /**
-   * Calculate auto-scroll deltas based on mouse position
-   */
-  private calculateAutoScroll;
-}
-//#endregion
-//#region ../core/src/highlight-manager.d.ts
-interface HighlightManagerOptions {
-  getActiveCell: () => CellPosition | null;
-  getSelectionRange: () => CellRange | null;
-  getColumn: (colIndex: number) => ColumnDefinition | undefined;
-}
-/**
- * Manages row/column/cell highlighting state and class computation.
- * Emits SET_HOVER_POSITION instructions when hover position changes.
- */
-declare class HighlightManager<TData = Record<string, unknown>> {
-  private options;
-  private highlightingOptions;
-  private hoverPosition;
-  private emitter;
-  onInstruction: (listener: InstructionListener) => () => void;
-  private emit;
-  private rowClassCache;
-  private columnClassCache;
-  private cellClassCache;
-  constructor(options: HighlightManagerOptions, highlightingOptions?: HighlightingOptions<TData>);
-  /**
-   * Check if highlighting is enabled (any callback defined).
-   * Hover tracking is automatically enabled when highlighting is enabled.
-   */
-  isEnabled(): boolean;
-  /**
-   * Update highlighting options. Clears all caches.
-   */
-  updateOptions(options: HighlightingOptions<TData>): void;
-  /**
-   * Set the current hover position. Clears caches and emits instruction.
-   * Hover tracking is automatically enabled when any highlighting callback is defined.
-   */
-  setHoverPosition(position: CellPosition | null): void;
-  /**
-   * Get the current hover position
-   */
-  getHoverPosition(): CellPosition | null;
-  /**
-   * Called when selection changes. Clears all caches.
-   */
-  onSelectionChange(): void;
-  /**
-   * Build context for row highlighting callback.
-   * Returns context with `rowIndex` set, `colIndex` is null.
-   * `isHovered` is true when the mouse is on any cell in this row.
-   */
-  buildRowContext(rowIndex: number, rowData?: TData): HighlightContext<TData>;
-  /**
-   * Build context for column highlighting callback.
-   * Returns context with `colIndex` set, `rowIndex` is null.
-   * `isHovered` is true when the mouse is on any cell in this column.
-   */
-  buildColumnContext(colIndex: number, column: ColumnDefinition): HighlightContext<TData>;
-  /**
-   * Build context for cell highlighting callback.
-   * Returns context with both `rowIndex` and `colIndex` set.
-   * `isHovered` is true only when the mouse is on this exact cell.
-   */
-  buildCellContext(rowIndex: number, colIndex: number, column: ColumnDefinition, rowData?: TData): HighlightContext<TData>;
-  /**
-   * Compute row classes using cache and user callback
-   */
-  computeRowClasses(rowIndex: number, rowData?: TData): string[];
-  /**
-   * Compute column classes using cache and user callback (or per-column override)
-   */
-  computeColumnClasses(colIndex: number, column: ColumnDefinition): string[];
-  /**
-   * Compute cell classes using cache and user callback (or per-column override)
-   */
-  computeCellClasses(rowIndex: number, colIndex: number, column: ColumnDefinition, rowData?: TData): string[];
-  /**
-   * Compute combined cell classes (column + cell classes flattened)
-   */
-  computeCombinedCellClasses(rowIndex: number, colIndex: number, column: ColumnDefinition, rowData?: TData): string[];
-  /**
-   * Clear all caches
-   */
-  clearAllCaches(): void;
-  /**
-   * Destroy the manager and release resources
-   */
-  destroy(): void;
-}
-//#endregion
-//#region ../core/src/sort-filter-manager.d.ts
-interface SortFilterManagerOptions<TData> {
-  /** Get all columns */
-  getColumns: () => ColumnDefinition[];
-  /** Check if sorting is enabled globally */
-  isSortingEnabled: () => boolean;
-  /** Get cached rows for distinct value computation */
-  getCachedRows: () => Map<number, TData>;
-  /** Called when sort/filter changes to trigger data refresh */
-  onSortFilterChange: () => Promise<void>;
-  /** Called after data refresh to update UI */
-  onDataRefreshed: () => void;
-}
-/**
- * Manages sorting and filtering state and operations.
- */
-declare class SortFilterManager<TData = Record<string, unknown>> {
-  private options;
-  private emitter;
-  private sortModel;
-  private filterModel;
-  private openFilterColIndex;
-  onInstruction: (listener: InstructionListener) => () => void;
-  private emit;
-  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>;
-  getFilterModel(): FilterModel;
-  /**
-   * Check if a column has an active filter
-   */
-  hasActiveFilter(colId: string): boolean;
-  /**
-   * Check if a column is sortable
-   */
-  isColumnSortable(colIndex: number): boolean;
-  /**
-   * Check if a column is filterable
-   */
-  isColumnFilterable(colIndex: number): boolean;
-  /**
-   * Get distinct values for a column (for filter dropdowns)
-   * For array-type columns (like tags), each unique array combination is returned.
-   * Arrays are sorted internally for consistent comparison.
-   * Limited to maxValues to avoid performance issues with large datasets.
-   */
-  getDistinctValuesForColumn(colId: string, maxValues?: number): CellValue[];
-  /**
-   * Open filter popup for a column (toggles if already open for same column)
-   */
-  openFilterPopup(colIndex: number, anchorRect: {
-    top: number;
-    left: number;
-    width: number;
-    height: number;
-  }): void;
-  /**
-   * Close filter popup
-   */
-  closeFilterPopup(): void;
-  /**
-   * Get sort info map for header rendering
-   */
-  getSortInfoMap(): Map<string, {
-    direction: SortDirection;
-    index: number;
-  }>;
-  destroy(): void;
-}
-//#endregion
-//#region ../core/src/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 extends Row = Row> {
-  private options;
-  private emitter;
-  onInstruction: (listener: InstructionListener) => () => void;
-  private 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 ../core/src/grid-core.d.ts
-declare class GridCore<TData extends Row = Row> {
-  private columns;
-  private dataSource;
-  private rowHeight;
-  private headerHeight;
-  private overscan;
-  private sortingEnabled;
-  private scrollTop;
-  private scrollLeft;
-  private viewportWidth;
-  private viewportHeight;
-  private cachedRows;
-  private totalRows;
-  private currentPageIndex;
-  private pageSize;
-  readonly selection: SelectionManager;
-  readonly fill: FillManager;
-  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 emitter;
-  onInstruction: (listener: InstructionListener) => () => void;
-  onBatchInstruction: (listener: BatchInstructionListener) => () => void;
-  private emit;
-  private emitBatch;
-  private naturalContentHeight;
-  private virtualContentHeight;
-  private scrollRatio;
-  private isDestroyed;
-  constructor(options: GridCoreOptions<TData>);
-  /**
-   * Initialize the grid and load initial data.
-   */
-  initialize(): Promise<void>;
-  /**
-   * Update viewport measurements and sync slots.
-   * When scroll virtualization is active, maps the DOM scroll position to the actual row position.
-   */
-  setViewport(scrollTop: number, scrollLeft: number, width: number, height: number): void;
-  private fetchData;
-  private fetchAllData;
-  setSort(colId: string, direction: SortDirection | null, addToExisting?: boolean): Promise<void>;
-  setFilter(colId: string, filter: ColumnFilterModel | string | null): Promise<void>;
-  hasActiveFilter(colId: string): boolean;
-  isColumnSortable(colIndex: number): boolean;
-  isColumnFilterable(colIndex: number): boolean;
-  getDistinctValuesForColumn(colId: string, maxValues?: number): CellValue[];
-  openFilterPopup(colIndex: number, anchorRect: {
-    top: number;
-    left: number;
-    width: number;
-    height: number;
-  }): void;
-  closeFilterPopup(): void;
-  getSortModel(): SortModel[];
-  getFilterModel(): FilterModel;
-  startEdit(row: number, col: number): void;
-  updateEditValue(value: CellValue): void;
-  commitEdit(): void;
-  cancelEdit(): void;
-  getEditState(): EditState | null;
-  getCellValue(row: number, col: number): CellValue;
-  setCellValue(row: number, col: number, value: CellValue): void;
-  private computeColumnPositions;
-  private emitContentSize;
-  private emitHeaders;
-  getColumns(): ColumnDefinition[];
-  getColumnPositions(): number[];
-  getRowCount(): number;
-  getRowHeight(): number;
-  getHeaderHeight(): number;
-  getTotalWidth(): number;
-  getTotalHeight(): 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 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;
-  getRowData(rowIndex: number): TData | undefined;
-  /**
-   * Refresh data from the data source.
-   */
-  refresh(): Promise<void>;
-  /**
-   * Refresh slot display without refetching data.
-   * 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.
-   */
-  setDataSource(dataSource: DataSource<TData>): Promise<void>;
-  /**
-   * Update columns and recompute layout.
-   */
-  setColumns(columns: ColumnDefinition[]): void;
-  /**
-   * Destroy the grid core and release all references.
-   * Call this before discarding the GridCore to ensure proper cleanup.
-   * This method is idempotent - safe to call multiple times.
-   */
-  destroy(): void;
-}
-//#endregion
-//#region ../core/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 ../core/src/data-source/client-data-source.d.ts
-interface ClientDataSourceOptions<TData> {
-  /** Custom field accessor for nested properties */
-  getFieldValue?: (row: TData, field: string) => CellValue;
-  /** 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 extends Row = Row>(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 extends Row = Row>(data: TData[]): DataSource<TData>;
-//#endregion
-//#region ../core/src/data-source/server-data-source.d.ts
-type ServerFetchFunction<TData> = (request: DataSourceRequest) => Promise<DataSourceResponse<TData>>;
-/**
- * Creates a server-side data source that delegates all operations to the server.
- * The fetch function receives sort/filter/pagination params to pass to the API.
- */
-declare function createServerDataSource<TData extends Row = Row>(fetchFn: ServerFetchFunction<TData>): DataSource<TData>;
-//#endregion
-//#region ../core/src/transaction-manager.d.ts
-interface TransactionResult {
-  added: number;
-  removed: number;
-  updated: number;
-}
-//#endregion
-//#region ../core/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 = Row> 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;
-}
-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;
-  /** Debounce time for transactions in ms. Default 50. Set to 0 for sync. */
-  debounceMs?: number;
-  /** Callback when transactions are processed. */
-  onTransactionProcessed?: (result: TransactionResult) => void;
-}
-/**
- * Creates a mutable client-side data source with transaction support.
- * Uses IndexedDataStore for efficient incremental operations.
- */
-declare function createMutableClientDataSource<TData extends Row = Row>(data: TData[], options: MutableClientDataSourceOptions<TData>): MutableDataSource<TData>;
-//#endregion
-//#region ../core/src/styles/index.d.ts
-/**
- * Combined grid styles from all modules
- */
-declare const gridStyles: string;
-/**
- * Inject grid styles into the document head.
- * This is called automatically when the Grid component mounts.
- * Styles are only injected once, even if multiple Grid instances exist.
- */
-declare function injectStyles(): void;
-//#endregion
-//#region ../core/src/types/ui-state.d.ts
-interface SlotData<TData = Row> {
-  slotId: string;
-  rowIndex: number;
-  rowData: TData;
-  translateY: number;
-}
-interface HeaderData {
-  column: ColumnDefinition;
-  sortDirection?: SortDirection;
-  sortIndex?: number;
-  sortable: boolean;
-  filterable: boolean;
-  hasFilter: boolean;
-}
-interface FilterPopupState {
-  isOpen: boolean;
-  colIndex: number;
-  column: ColumnDefinition | null;
-  anchorRect: {
-    top: number;
-    left: number;
-    width: number;
-    height: number;
-  } | null;
-  distinctValues: CellValue[];
-  currentFilter?: ColumnFilterModel;
-}
-interface GridState<TData = Row> {
-  slots: Map<string, SlotData<TData>>;
-  activeCell: CellPosition | null;
-  selectionRange: CellRange | null;
-  editingCell: {
-    row: number;
-    col: number;
-    initialValue: CellValue;
-  } | null;
-  contentWidth: number;
-  contentHeight: number;
-  /** Viewport width (container's visible width) for column scaling */
-  viewportWidth: number;
-  headers: Map<number, HeaderData>;
-  filterPopup: FilterPopupState | null;
-  isLoading: boolean;
-  error: string | null;
-  totalRows: number;
-  /** Visible row range (start inclusive, end inclusive). Used to prevent selection showing in overscan. */
-  visibleRowRange: {
-    start: number;
-    end: number;
-  } | null;
-  /** Currently hovered cell position (for highlighting) */
-  hoverPosition: CellPosition | null;
-}
-//#endregion
 //#region src/types.d.ts
 /**
  * Vue cell renderer - can return a VNode or a string
  */
-type VueCellRenderer<TData extends Row = Row> = (params: CellRendererParams<TData>) => VNode | string | null;
+type VueCellRenderer<TData extends Row$1 = Row$1> = (params: CellRendererParams$1<TData>) => VNode | string | null;
 /**
  * Vue edit renderer - returns a VNode for the edit input
  */
-type VueEditRenderer<TData extends Row = Row> = (params: EditRendererParams<TData>) => VNode | null;
+type VueEditRenderer<TData extends Row$1 = Row$1> = (params: EditRendererParams$1<TData>) => VNode | null;
 /**
  * Vue header renderer - returns a VNode for the header content
  */
-type VueHeaderRenderer = (params: HeaderRendererParams) => VNode | string | null;
-interface GpGridProps<TData extends Row = Row> {
-  columns: ColumnDefinition[];
-  dataSource?: DataSource<TData>;
+type VueHeaderRenderer = (params: HeaderRendererParams$1) => VNode | string | null;
+interface GpGridProps<TData extends Row$1 = Row$1> {
+  columns: ColumnDefinition$1[];
+  dataSource?: DataSource$1<TData>;
   rowData?: TData[];
   rowHeight: number;
   headerHeight?: number;
@@ -1421,19 +26,27 @@ interface GpGridProps<TData extends Row = Row> {
   sortingEnabled?: boolean;
   darkMode?: boolean;
   wheelDampening?: number;
-  cellRenderers?: Record<string, VueCellRenderer<TData> | Component>;
-  editRenderers?: Record<string, VueEditRenderer<TData> | Component>;
-  headerRenderers?: Record<string, VueHeaderRenderer | Component>;
-  cellRenderer?: VueCellRenderer<TData> | Component;
-  editRenderer?: VueEditRenderer<TData> | Component;
-  headerRenderer?: VueHeaderRenderer | Component;
+  cellRenderers?: Record<string, VueCellRenderer<TData> | Component$1>;
+  editRenderers?: Record<string, VueEditRenderer<TData> | Component$1>;
+  headerRenderers?: Record<string, VueHeaderRenderer | Component$1>;
+  cellRenderer?: VueCellRenderer<TData> | Component$1;
+  editRenderer?: VueEditRenderer<TData> | Component$1;
+  headerRenderer?: VueHeaderRenderer | Component$1;
+  /** Function to extract unique ID from row. Required when onCellValueChanged is provided. */
+  getRowId?: (row: TData) => RowId$1;
+  /** Called when a cell value is changed via editing or fill drag. Requires getRowId. */
+  onCellValueChanged?: (event: CellValueChangedEvent$1<TData>) => void;
+  /** Custom loading component to render instead of default spinner */
+  loadingComponent?: Component$1<{
+    isLoading: boolean;
+  }>;
 }
 //#endregion
 //#region src/GpGrid.vue.d.ts
 type __VLS_Props = {
-  columns: ColumnDefinition[];
-  dataSource?: DataSource<Row>;
-  rowData?: Row[];
+  columns: ColumnDefinition$1[];
+  dataSource?: DataSource$1<Row$1>;
+  rowData?: Row$1[];
   rowHeight: number;
   headerHeight?: number;
   overscan?: number;
@@ -1445,17 +58,19 @@ type __VLS_Props = {
   headerRenderers?: Record<string, VueHeaderRenderer>;
   cellRenderer?: VueCellRenderer;
   editRenderer?: VueEditRenderer;
-  headerRenderer?: VueHeaderRenderer;
-  /** Initial viewport width for SSR (pixels). ResizeObserver takes over on client. */
-  initialWidth?: number;
-  /** Initial viewport height for SSR (pixels). ResizeObserver takes over on client. */
-  initialHeight?: number;
-  /** Row/column/cell highlighting configuration */
-  highlighting?: HighlightingOptions<Row>;
+  headerRenderer?: VueHeaderRenderer; /** Initial viewport width for SSR (pixels). ResizeObserver takes over on client. */
+  initialWidth?: number; /** Initial viewport height for SSR (pixels). ResizeObserver takes over on client. */
+  initialHeight?: number; /** Row/column/cell highlighting configuration */
+  highlighting?: HighlightingOptions<Row$1>; /** Function to extract unique ID from row. Required when onCellValueChanged is provided. */
+  getRowId?: (row: Row$1) => RowId$1; /** Called when a cell value is changed via editing or fill drag. Requires getRowId. */
+  onCellValueChanged?: (event: CellValueChangedEvent$1<Row$1>) => void; /** Custom loading component to render instead of default spinner */
+  loadingComponent?: Component<{
+    isLoading: boolean;
+  }>;
 };
-declare const __VLS_export: vue0.DefineComponent<__VLS_Props, {
-  core: vue0.ShallowRef<GridCore<unknown> | null, GridCore<unknown> | null>;
-}, {}, {}, {}, vue0.ComponentOptionsMixin, vue0.ComponentOptionsMixin, {}, string, vue0.PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+declare const __VLS_export: vue.DefineComponent<__VLS_Props, {
+  core: vue.ShallowRef<GridCore$1<unknown> | null, GridCore$1<unknown> | null>;
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
   overscan: number;
   sortingEnabled: boolean;
   darkMode: boolean;
@@ -1463,13 +78,13 @@ declare const __VLS_export: vue0.DefineComponent<__VLS_Props, {
   cellRenderers: Record<string, VueCellRenderer>;
   editRenderers: Record<string, VueEditRenderer>;
   headerRenderers: Record<string, VueHeaderRenderer>;
-}, {}, {}, {}, string, vue0.ComponentProvideOptions, false, {}, any>;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 //#endregion
 //#region src/composables/useGpGrid.d.ts
-interface UseGpGridOptions<TData extends Row = Row> {
-  columns: ColumnDefinition[];
-  dataSource?: DataSource<TData>;
+interface UseGpGridOptions<TData extends Row$1 = Row$1> {
+  columns: ColumnDefinition$1[];
+  dataSource?: DataSource$1<TData>;
   rowData?: TData[];
   rowHeight: number;
   headerHeight?: number;
@@ -1478,6 +93,10 @@ interface UseGpGridOptions<TData extends Row = Row> {
   darkMode?: boolean;
   wheelDampening?: number;
   highlighting?: HighlightingOptions<TData>;
+  /** Function to extract unique ID from row. Required when onCellValueChanged is provided. */
+  getRowId?: (row: TData) => RowId$1;
+  /** Called when a cell value is changed via editing or fill drag. Requires getRowId. */
+  onCellValueChanged?: (event: CellValueChangedEvent$1<TData>) => void;
   cellRenderers?: Record<string, VueCellRenderer<TData>>;
   editRenderers?: Record<string, VueEditRenderer<TData>>;
   headerRenderers?: Record<string, VueHeaderRenderer>;
@@ -1485,11 +104,11 @@ interface UseGpGridOptions<TData extends Row = Row> {
   editRenderer?: VueEditRenderer<TData>;
   headerRenderer?: VueHeaderRenderer;
 }
-interface UseGpGridResult<TData extends Row = Row> {
+interface UseGpGridResult<TData extends Row$1 = Row$1> {
   containerRef: Ref<HTMLDivElement | null>;
-  coreRef: Ref<GridCore<TData> | null>;
-  state: GridState;
-  slotsArray: ComputedRef<SlotData[]>;
+  coreRef: Ref<GridCore$1<TData> | null>;
+  state: GridState$1;
+  slotsArray: ComputedRef<SlotData$1[]>;
   totalHeaderHeight: ComputedRef<number>;
   columnPositions: ComputedRef<number[]>;
   columnWidths: ComputedRef<number[]>;
@@ -1505,7 +124,7 @@ interface UseGpGridResult<TData extends Row = Row> {
   handleHeaderClick: (colIndex: number, e: MouseEvent) => void;
   handleKeyDown: (e: KeyboardEvent) => void;
   handleWheel: (e: WheelEvent, wheelDampening: number) => void;
-  handleFilterApply: (colId: string, filter: ColumnFilterModel | null) => void;
+  handleFilterApply: (colId: string, filter: ColumnFilterModel$1 | null) => void;
   handleFilterPopupClose: () => void;
   handleCellMouseEnter: (rowIndex: number, colIndex: number) => void;
   handleCellMouseLeave: () => void;
@@ -1523,26 +142,78 @@ interface UseGpGridResult<TData extends Row = Row> {
       col: number;
     } | null;
   }>;
-  isCellSelected: typeof isCellSelected;
-  isCellActive: typeof isCellActive;
-  isCellEditing: typeof isCellEditing;
-  isCellInFillPreview: typeof isCellInFillPreview;
-  buildCellClasses: typeof buildCellClasses;
+  isCellSelected: typeof isCellSelected$1;
+  isCellActive: typeof isCellActive$1;
+  isCellEditing: typeof isCellEditing$1;
+  isCellInFillPreview: typeof isCellInFillPreview$1;
+  buildCellClasses: typeof buildCellClasses$1;
 }
 /**
  * Nuxt-friendly composable for using gp-grid.
  * Returns all the pieces needed to build a custom grid component.
  */
-declare function useGpGrid<TData extends Row = Row>(options: UseGpGridOptions<TData>): UseGpGridResult<TData>;
+declare function useGpGrid<TData extends Row$1 = Row$1>(options: UseGpGridOptions<TData>): UseGpGridResult<TData>;
+//#endregion
+//#region src/composables/useGridData.d.ts
+interface UseGridDataOptions<TData> {
+  /** Function to extract a unique ID from each row. Required. */
+  getRowId: (row: TData) => RowId$1;
+  /** Debounce time for batching transactions in ms. Default 50. */
+  debounceMs?: number;
+  /** Use Web Worker for sorting large datasets (default: true) */
+  useWorker?: boolean;
+  /** Options for parallel sorting (only used when useWorker is true) */
+  parallelSort?: ParallelSortOptions | false;
+}
+interface UseGridDataResult<TData> {
+  /** The data source to pass to <GpGrid :data-source="dataSource" />. */
+  dataSource: MutableDataSource$1<TData>;
+  /** Update a single row by ID with partial data. */
+  updateRow: (id: RowId$1, data: Partial<TData>) => void;
+  /** Add rows to the data source. */
+  addRows: (rows: TData[]) => void;
+  /** Remove rows by ID. */
+  removeRows: (ids: RowId$1[]) => void;
+  /** Update a single cell value. */
+  updateCell: (id: RowId$1, field: string, value: CellValue$1) => void;
+  /** Clear all data from the data source. */
+  clear: () => void;
+  /** Get a row by its ID. */
+  getRowById: (id: RowId$1) => TData | undefined;
+  /** Get the current total row count. */
+  getTotalRowCount: () => number;
+  /** Force immediate processing of queued transactions. */
+  flushTransactions: () => Promise<void>;
+}
+/**
+ * Vue composable for efficient grid data mutations.
+ *
+ * Wraps `createMutableClientDataSource` to provide a simple API for
+ * updating grid data without triggering full pipeline rebuilds.
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * const { dataSource, updateRow, addRows } = useGridData(initialData, {
+ *   getRowId: (row) => row.id,
+ * });
+ * </script>
+ *
+ * <template>
+ *   <GpGrid :data-source="dataSource" :columns="columns" :row-height="36" />
+ * </template>
+ * ```
+ */
+declare const useGridData: <TData extends Row$1 = Row$1>(initialData: TData[], options: UseGridDataOptions<TData>) => UseGridDataResult<TData>;
 //#endregion
 //#region src/composables/useInputHandler.d.ts
 interface VisibleColumnInfo$1 {
-  column: ColumnDefinition;
+  column: ColumnDefinition$1;
   originalIndex: number;
 }
 interface UseInputHandlerOptions {
-  activeCell: ComputedRef<CellPosition | null>;
-  selectionRange: ComputedRef<CellRange | null>;
+  activeCell: ComputedRef<CellPosition$1 | null>;
+  selectionRange: ComputedRef<CellRange$1 | null>;
   editingCell: ComputedRef<{
     row: number;
     col: number;
@@ -1553,7 +224,7 @@ interface UseInputHandlerOptions {
   columnPositions: ComputedRef<number[]>;
   /** Visible columns with their original indices (for hidden column support) */
   visibleColumnsWithIndices: ComputedRef<VisibleColumnInfo$1[]>;
-  slots: ComputedRef<Map<string, SlotData>>;
+  slots: ComputedRef<Map<string, SlotData$1>>;
 }
 interface UseInputHandlerResult {
   handleCellMouseDown: (rowIndex: number, colIndex: number, e: MouseEvent) => void;
@@ -1562,12 +233,12 @@ interface UseInputHandlerResult {
   handleHeaderClick: (colIndex: number, e: MouseEvent) => void;
   handleKeyDown: (e: KeyboardEvent) => void;
   handleWheel: (e: WheelEvent, wheelDampening: number) => void;
-  dragState: Ref<DragState>;
+  dragState: Ref<DragState$1>;
 }
 /**
  * Vue composable for handling all input interactions
  */
-declare function useInputHandler<TData extends Row = Row>(coreRef: ShallowRef<GridCore<TData> | null>, containerRef: Ref<HTMLDivElement | null>, columns: ComputedRef<ColumnDefinition[]>, options: UseInputHandlerOptions): UseInputHandlerResult;
+declare function useInputHandler<TData extends Row$1 = Row$1>(coreRef: ShallowRef<GridCore$1<TData> | null>, containerRef: Ref<HTMLDivElement | null>, columns: ComputedRef<ColumnDefinition$1[]>, options: UseInputHandlerOptions): UseInputHandlerResult;
 //#endregion
 //#region src/composables/useAutoScroll.d.ts
 /**
@@ -1580,14 +251,14 @@ declare function useAutoScroll(containerRef: Ref<HTMLDivElement | null>): {
 //#endregion
 //#region src/composables/useFillHandle.d.ts
 interface VisibleColumnInfo {
-  column: ColumnDefinition;
+  column: ColumnDefinition$1;
   originalIndex: number;
 }
 interface UseFillHandleOptions {
-  activeCell: ComputedRef<CellPosition | null>;
-  selectionRange: ComputedRef<CellRange | null>;
-  slots: ComputedRef<Map<string, SlotData>>;
-  columns: ComputedRef<ColumnDefinition[]>;
+  activeCell: ComputedRef<CellPosition$1 | null>;
+  selectionRange: ComputedRef<CellRange$1 | null>;
+  slots: ComputedRef<Map<string, SlotData$1>>;
+  columns: ComputedRef<ColumnDefinition$1[]>;
   visibleColumnsWithIndices: ComputedRef<VisibleColumnInfo[]>;
   columnPositions: ComputedRef<number[]>;
   columnWidths: ComputedRef<number[]>;
@@ -1642,7 +313,7 @@ interface InitialStateArgs {
   initialWidth?: number;
   initialHeight?: number;
 }
-declare function createInitialState(args?: InitialStateArgs): GridState;
+declare function createInitialState(args?: InitialStateArgs): GridState$1;
 /**
  * Vue composable for managing grid state
  */
@@ -1653,7 +324,7 @@ declare function useGridState(args?: InitialStateArgs): {
       rowIndex: number;
       rowData: unknown;
       translateY: number;
-    }> & Omit<Map<string, SlotData<unknown>>, keyof Map<any, any>>;
+    }> & Omit<Map<string, SlotData$1<unknown>>, keyof Map<any, any>>;
     activeCell: {
       row: number;
       col: number;
@@ -1667,16 +338,18 @@ declare function useGridState(args?: InitialStateArgs): {
     editingCell: {
       row: number;
       col: number;
-      initialValue: CellValue;
+      initialValue: _gp_grid_core0.CellValue;
     } | null;
     contentWidth: number;
     contentHeight: number;
     viewportWidth: number;
+    viewportHeight: number;
+    rowsWrapperOffset: number;
     headers: Map<number, {
       column: {
         field: string;
         colId?: string | undefined;
-        cellDataType: CellDataType;
+        cellDataType: _gp_grid_core0.CellDataType;
         width: number;
         headerName?: string | undefined;
         editable?: boolean | undefined;
@@ -1686,22 +359,22 @@ declare function useGridState(args?: InitialStateArgs): {
         cellRenderer?: string | undefined;
         editRenderer?: string | undefined;
         headerRenderer?: string | undefined;
-        computeColumnClasses?: ((context: HighlightContext) => string[]) | undefined;
-        computeCellClasses?: ((context: HighlightContext) => string[]) | undefined;
+        computeColumnClasses?: ((context: _gp_grid_core0.HighlightContext) => string[]) | undefined;
+        computeCellClasses?: ((context: _gp_grid_core0.HighlightContext) => string[]) | undefined;
       };
-      sortDirection?: SortDirection | undefined;
+      sortDirection?: _gp_grid_core0.SortDirection | undefined;
       sortIndex?: number | undefined;
       sortable: boolean;
       filterable: boolean;
       hasFilter: boolean;
-    }> & Omit<Map<number, HeaderData>, keyof Map<any, any>>;
+    }> & Omit<Map<number, HeaderData$1>, keyof Map<any, any>>;
     filterPopup: {
       isOpen: boolean;
       colIndex: number;
       column: {
         field: string;
         colId?: string | undefined;
-        cellDataType: CellDataType;
+        cellDataType: _gp_grid_core0.CellDataType;
         width: number;
         headerName?: string | undefined;
         editable?: boolean | undefined;
@@ -1711,8 +384,8 @@ declare function useGridState(args?: InitialStateArgs): {
         cellRenderer?: string | undefined;
         editRenderer?: string | undefined;
         headerRenderer?: string | undefined;
-        computeColumnClasses?: ((context: HighlightContext) => string[]) | undefined;
-        computeCellClasses?: ((context: HighlightContext) => string[]) | undefined;
+        computeColumnClasses?: ((context: _gp_grid_core0.HighlightContext) => string[]) | undefined;
+        computeCellClasses?: ((context: _gp_grid_core0.HighlightContext) => string[]) | undefined;
       } | null;
       anchorRect: {
         top: number;
@@ -1720,29 +393,29 @@ declare function useGridState(args?: InitialStateArgs): {
         width: number;
         height: number;
       } | null;
-      distinctValues: CellValue[];
+      distinctValues: _gp_grid_core0.CellValue[];
       currentFilter?: {
         conditions: ({
           type: "text";
-          operator: TextFilterOperator;
+          operator: _gp_grid_core0.TextFilterOperator;
           value?: string | undefined;
           selectedValues?: (Set<string> & Omit<Set<string>, keyof Set<any>>) | undefined;
           includeBlank?: boolean | undefined;
-          nextOperator?: FilterCombination | undefined;
+          nextOperator?: _gp_grid_core0.FilterCombination | undefined;
         } | {
           type: "number";
-          operator: NumberFilterOperator;
+          operator: _gp_grid_core0.NumberFilterOperator;
           value?: number | undefined;
           valueTo?: number | undefined;
-          nextOperator?: FilterCombination | undefined;
+          nextOperator?: _gp_grid_core0.FilterCombination | undefined;
         } | {
           type: "date";
-          operator: DateFilterOperator;
+          operator: _gp_grid_core0.DateFilterOperator;
           value?: (Date | string) | undefined;
           valueTo?: (Date | string) | undefined;
-          nextOperator?: FilterCombination | undefined;
+          nextOperator?: _gp_grid_core0.FilterCombination | undefined;
         })[];
-        combination: FilterCombination;
+        combination: _gp_grid_core0.FilterCombination;
       } | undefined;
     } | null;
     isLoading: boolean;
@@ -1757,7 +430,7 @@ declare function useGridState(args?: InitialStateArgs): {
       col: number;
     } | null;
   };
-  applyInstructions: (instructions: GridInstruction[]) => void;
+  applyInstructions: (instructions: GridInstruction$1[]) => void;
   reset: () => void;
 };
 //#endregion
@@ -1765,10 +438,10 @@ declare function useGridState(args?: InitialStateArgs): {
 /**
  * Get cell value from row data, supporting dot-notation for nested fields
  */
-declare function getCellValue(rowData: Row, field: string): CellValue;
+declare function getCellValue(rowData: Row$1, field: string): CellValue$1;
 interface RenderCellOptions {
-  column: ColumnDefinition;
-  rowData: Row;
+  column: ColumnDefinition$1;
+  rowData: Row$1;
   rowIndex: number;
   colIndex: number;
   isActive: boolean;
@@ -1784,12 +457,12 @@ declare function renderCell(options: RenderCellOptions): VNode;
 //#endregion
 //#region src/renderers/editRenderer.d.ts
 interface RenderEditCellOptions {
-  column: ColumnDefinition;
-  rowData: Row;
+  column: ColumnDefinition$1;
+  rowData: Row$1;
   rowIndex: number;
   colIndex: number;
-  initialValue: CellValue;
-  core: GridCore | null;
+  initialValue: CellValue$1;
+  core: GridCore$1 | null;
   editRenderers: Record<string, VueEditRenderer>;
   globalEditRenderer?: VueEditRenderer;
 }
@@ -1800,14 +473,14 @@ declare function renderEditCell(options: RenderEditCellOptions): VNode;
 //#endregion
 //#region src/renderers/headerRenderer.d.ts
 interface RenderHeaderOptions {
-  column: ColumnDefinition;
+  column: ColumnDefinition$1;
   colIndex: number;
-  sortDirection?: SortDirection;
+  sortDirection?: SortDirection$1;
   sortIndex?: number;
   sortable: boolean;
   filterable: boolean;
   hasFilter: boolean;
-  core: GridCore | null;
+  core: GridCore$1 | null;
   container: HTMLDivElement | null;
   headerRenderers: Record<string, VueHeaderRenderer>;
   globalHeaderRenderer?: VueHeaderRenderer;
@@ -1817,4 +490,4 @@ interface RenderHeaderOptions {
  */
 declare function renderHeader(options: RenderHeaderOptions): VNode;
 //#endregion
-export { type CellDataType, type CellPosition, type CellRange, type CellRendererParams, type CellValue, type ColumnDefinition, type ColumnFilterModel, type ContainerBounds, type DataSource, type DataSourceRequest, type DataSourceResponse, type DateFilterCondition, type DragState, type EditRendererParams, type FilterCondition, type FilterModel, type FilterPopupState, _default as GpGrid, _default as default, type GpGridProps, GridCore, type GridInstruction, type GridState, type HeaderData, type HeaderRendererParams, type KeyEventData, type LocalFilterCondition, type MutableDataSource, type NumberFilterCondition, type PointerEventData, type Row, type RowId, type SelectionState, type SlotData, type SortDirection, type SortModel, type TextFilterCondition, type UseFillHandleOptions, type UseFillHandleResult, type UseFilterConditionsResult, type UseFilterPopupOptions, type UseGpGridOptions, type UseGpGridResult, type UseInputHandlerOptions, type UseInputHandlerResult, type VueCellRenderer, type VueEditRenderer, type VueHeaderRenderer, buildCellClasses, calculateColumnPositions, createClientDataSource, createDataSourceFromArray, createInitialState, createMutableClientDataSource, createServerDataSource, findColumnAtX, getCellValue, getTotalWidth, gridStyles, injectStyles, isCellActive, isCellEditing, isCellInFillPreview, isCellSelected, isRowVisible, renderCell, renderEditCell, renderHeader, useAutoScroll, useFillHandle, useFilterConditions, useFilterPopup, useGpGrid, useGridState, useInputHandler };
+export { type CellDataType, type CellPosition, type CellRange, type CellRendererParams, type CellValue, type CellValueChangedEvent, type ColumnDefinition, type ColumnFilterModel, type ContainerBounds, type DataSource, type DataSourceRequest, type DataSourceResponse, type DateFilterCondition, type DragState, type EditRendererParams, type FilterCondition, type FilterModel, type FilterPopupState, _default as GpGrid, _default as default, type GpGridProps, GridCore, type GridInstruction, type GridState, type HeaderData, type HeaderRendererParams, type KeyEventData, type LocalFilterCondition, type MutableDataSource, type NumberFilterCondition, type PointerEventData, type Row, type RowId, type SelectionState, type SlotData, type SortDirection, type SortModel, type TextFilterCondition, type UseFillHandleOptions, type UseFillHandleResult, type UseFilterConditionsResult, type UseFilterPopupOptions, type UseGpGridOptions, type UseGpGridResult, type UseGridDataOptions, type UseGridDataResult, type UseInputHandlerOptions, type UseInputHandlerResult, type VueCellRenderer, type VueEditRenderer, type VueHeaderRenderer, buildCellClasses, calculateColumnPositions, createClientDataSource, createDataSourceFromArray, createInitialState, createMutableClientDataSource, createServerDataSource, findColumnAtX, getCellValue, getTotalWidth, gridStyles, injectStyles, isCellActive, isCellEditing, isCellInFillPreview, isCellSelected, isRowVisible, renderCell, renderEditCell, renderHeader, useAutoScroll, useFillHandle, useFilterConditions, useFilterPopup, useGpGrid, useGridData, useGridState, useInputHandler };