gp-grid-vue 0.1.6

package/dist/index.d.ts

@@ -0,0 +1,1426 @@
+import * as vue0 from "vue";
+import { Component, ComputedRef, Ref, ShallowRef, VNode } from "vue";
+
+//#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/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;
+  /** Renderer key for adapter lookup, or inline renderer function */
+  cellRenderer?: string;
+  editRenderer?: string;
+  headerRenderer?: 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>>;
+}
+//#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 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;
+}
+/** 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";
+  count: number;
+  totalRows: number;
+}
+/** Rows removed instruction */
+interface RowsRemovedInstruction {
+  type: "ROWS_REMOVED";
+  count: number;
+  totalRows: number;
+}
+/** Rows updated instruction */
+interface RowsUpdatedInstruction {
+  type: "ROWS_UPDATED";
+  count: 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
+/** 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;
+/** Batch instruction listener: Batch instruction Listener that receives an array of instructions, used by frameworks to update their state */
+type BatchInstructionListener = (instructions: GridInstruction[]) => void;
+//#endregion
+//#region ../core/src/types/renderers.d.ts
+/** Cell renderer params */
+interface CellRendererParams {
+  /** Cell value */
+  value: CellValue;
+  /** Row data */
+  rowData: Row;
+  /** 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 extends CellRendererParams {
+  /** 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;
+}
+//#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 */
+  getColumnPositions: () => number[];
+  /** Get column count */
+  getColumnCount: () => 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/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 listeners;
+  constructor(options: SelectionManagerOptions);
+  onInstruction(listener: InstructionListener): () => void;
+  private emit;
+  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>;
+  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 listeners;
+  constructor(options: FillManagerOptions);
+  onInstruction(listener: InstructionListener): () => void;
+  private emit;
+  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;
+  /**
+   * 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 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;
+  /**
+   * Find column index at a given X coordinate
+   */
+  private findColumnAtX;
+  /**
+   * Calculate auto-scroll deltas based on mouse position
+   */
+  private calculateAutoScroll;
+}
+//#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;
+  private sortModel;
+  private filterModel;
+  private openFilterColIndex;
+  readonly selection: SelectionManager;
+  readonly fill: FillManager;
+  readonly input: InputHandler<TData>;
+  private readonly slotPool;
+  private readonly editManager;
+  private columnPositions;
+  private listeners;
+  private batchListeners;
+  private naturalContentHeight;
+  private virtualContentHeight;
+  private scrollRatio;
+  constructor(options: GridCoreOptions<TData>);
+  onInstruction(listener: InstructionListener): () => void;
+  /**
+   * Subscribe to batched instructions for efficient React state updates.
+   * Batch listeners receive arrays of instructions instead of individual ones.
+   */
+  onBatchInstruction(listener: BatchInstructionListener): () => void;
+  private emit;
+  private emitBatch;
+  /**
+   * 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>;
+  /**
+   * 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 MAX_DISTINCT_VALUES 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;
+  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 getFieldValue;
+  private setFieldValue;
+  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;
+  /**
+   * Update the data source and refresh.
+   */
+  setDataSource(dataSource: DataSource<TData>): Promise<void>;
+  /**
+   * Update columns and recompute layout.
+   */
+  setColumns(columns: ColumnDefinition[]): void;
+}
+//#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;
+}
+/**
+ * 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;
+}
+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/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 function calculateColumnPositions(columns: ColumnDefinition[]): number[];
+/**
+ * Get total width from column positions
+ */
+declare function getTotalWidth(columnPositions: number[]): number;
+/**
+ * Find column index at a given X coordinate
+ */
+declare function findColumnAtX(x: number, columnPositions: number[]): number;
+//#endregion
+//#region ../core/src/utils/classNames.d.ts
+/**
+ * Check if a cell is within the selection range
+ */
+declare function isCellSelected(row: number, col: number, selectionRange: CellRange | null): boolean;
+/**
+ * Check if a cell is the active cell
+ */
+declare function isCellActive(row: number, col: number, activeCell: CellPosition | null): boolean;
+/**
+ * Check if a row is within the visible range (not in overscan)
+ */
+declare function isRowVisible(row: number, visibleRowRange: {
+  start: number;
+  end: number;
+} | null): boolean;
+/**
+ * Check if a cell is being edited
+ */
+declare function 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 function isCellInFillPreview(row: number, col: number, isDraggingFill: boolean, fillSourceRange: {
+  startRow: number;
+  startCol: number;
+  endRow: number;
+  endCol: number;
+} | null, fillTarget: {
+  row: number;
+  col: number;
+} | null): boolean;
+/**
+ * Build cell CSS classes based on state
+ */
+declare function buildCellClasses(isActive: boolean, isSelected: boolean, isEditing: boolean, inFillPreview: boolean): string;
+//#endregion
+//#region ../core/src/types/ui-state.d.ts
+interface SlotData {
+  slotId: string;
+  rowIndex: number;
+  rowData: Row;
+  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 {
+  slots: Map<string, SlotData>;
+  activeCell: CellPosition | null;
+  selectionRange: CellRange | null;
+  editingCell: {
+    row: number;
+    col: number;
+    initialValue: CellValue;
+  } | null;
+  contentWidth: number;
+  contentHeight: 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;
+}
+//#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;
+/**
+ * Vue edit renderer - returns a VNode for the edit input
+ */
+type VueEditRenderer<TData extends Row = Row> = (params: EditRendererParams<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>;
+  rowData?: TData[];
+  rowHeight: number;
+  headerHeight?: number;
+  overscan?: number;
+  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;
+}
+//#endregion
+//#region src/GpGrid.vue.d.ts
+type __VLS_Props = {
+  columns: ColumnDefinition[];
+  dataSource?: DataSource<Row>;
+  rowData?: Row[];
+  rowHeight: number;
+  headerHeight?: number;
+  overscan?: number;
+  sortingEnabled?: boolean;
+  darkMode?: boolean;
+  wheelDampening?: number;
+  cellRenderers?: Record<string, VueCellRenderer>;
+  editRenderers?: Record<string, VueEditRenderer>;
+  headerRenderers?: Record<string, VueHeaderRenderer>;
+  cellRenderer?: VueCellRenderer;
+  editRenderer?: VueEditRenderer;
+  headerRenderer?: VueHeaderRenderer;
+};
+declare const __VLS_export: vue0.DefineComponent<__VLS_Props, {}, {}, {}, {}, vue0.ComponentOptionsMixin, vue0.ComponentOptionsMixin, {}, string, vue0.PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+  overscan: number;
+  sortingEnabled: boolean;
+  darkMode: boolean;
+  wheelDampening: number;
+  cellRenderers: Record<string, VueCellRenderer>;
+  editRenderers: Record<string, VueEditRenderer>;
+  headerRenderers: Record<string, VueHeaderRenderer>;
+}, {}, {}, {}, string, vue0.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>;
+  rowData?: TData[];
+  rowHeight: number;
+  headerHeight?: number;
+  overscan?: number;
+  sortingEnabled?: boolean;
+  darkMode?: boolean;
+  wheelDampening?: number;
+  cellRenderers?: Record<string, VueCellRenderer<TData>>;
+  editRenderers?: Record<string, VueEditRenderer<TData>>;
+  headerRenderers?: Record<string, VueHeaderRenderer>;
+  cellRenderer?: VueCellRenderer<TData>;
+  editRenderer?: VueEditRenderer<TData>;
+  headerRenderer?: VueHeaderRenderer;
+}
+interface UseGpGridResult<TData extends Row = Row> {
+  containerRef: Ref<HTMLDivElement | null>;
+  coreRef: Ref<GridCore<TData> | null>;
+  state: GridState;
+  slotsArray: ComputedRef<SlotData[]>;
+  totalHeaderHeight: ComputedRef<number>;
+  columnPositions: ComputedRef<number[]>;
+  totalWidth: ComputedRef<number>;
+  fillHandlePosition: ComputedRef<{
+    top: number;
+    left: number;
+  } | null>;
+  handleScroll: () => void;
+  handleCellMouseDown: (rowIndex: number, colIndex: number, e: MouseEvent) => void;
+  handleCellDoubleClick: (rowIndex: number, colIndex: number) => void;
+  handleFillHandleMouseDown: (e: MouseEvent) => void;
+  handleHeaderClick: (colIndex: number, e: MouseEvent) => void;
+  handleKeyDown: (e: KeyboardEvent) => void;
+  handleWheel: (e: WheelEvent, wheelDampening: number) => void;
+  handleFilterApply: (colId: string, filter: ColumnFilterModel | null) => void;
+  handleFilterPopupClose: () => void;
+  dragState: Ref<{
+    isDragging: boolean;
+    dragType: "selection" | "fill" | null;
+    fillSourceRange: {
+      startRow: number;
+      startCol: number;
+      endRow: number;
+      endCol: number;
+    } | null;
+    fillTarget: {
+      row: number;
+      col: number;
+    } | null;
+  }>;
+  isCellSelected: typeof isCellSelected;
+  isCellActive: typeof isCellActive;
+  isCellEditing: typeof isCellEditing;
+  isCellInFillPreview: typeof isCellInFillPreview;
+  buildCellClasses: typeof buildCellClasses;
+}
+/**
+ * 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>;
+//#endregion
+//#region src/composables/useInputHandler.d.ts
+interface UseInputHandlerOptions {
+  activeCell: ComputedRef<CellPosition | null>;
+  selectionRange: ComputedRef<CellRange | null>;
+  editingCell: ComputedRef<{
+    row: number;
+    col: number;
+  } | null>;
+  filterPopupOpen: ComputedRef<boolean>;
+  rowHeight: number;
+  headerHeight: number;
+  columnPositions: ComputedRef<number[]>;
+  slots: ComputedRef<Map<string, SlotData>>;
+}
+interface UseInputHandlerResult {
+  handleCellMouseDown: (rowIndex: number, colIndex: number, e: MouseEvent) => void;
+  handleCellDoubleClick: (rowIndex: number, colIndex: number) => void;
+  handleFillHandleMouseDown: (e: MouseEvent) => void;
+  handleHeaderClick: (colIndex: number, e: MouseEvent) => void;
+  handleKeyDown: (e: KeyboardEvent) => void;
+  handleWheel: (e: WheelEvent, wheelDampening: number) => void;
+  dragState: Ref<DragState>;
+}
+/**
+ * Vue composable for handling all input interactions
+ */
+declare function useInputHandler(coreRef: ShallowRef<GridCore | null>, containerRef: Ref<HTMLDivElement | null>, columns: ComputedRef<ColumnDefinition[]>, options: UseInputHandlerOptions): UseInputHandlerResult;
+//#endregion
+//#region src/composables/useAutoScroll.d.ts
+/**
+ * Vue composable for auto-scrolling during drag operations
+ */
+declare function useAutoScroll(containerRef: Ref<HTMLDivElement | null>): {
+  startAutoScroll: (dx: number, dy: number) => void;
+  stopAutoScroll: () => void;
+};
+//#endregion
+//#region src/composables/useFillHandle.d.ts
+interface UseFillHandleOptions {
+  activeCell: ComputedRef<CellPosition | null>;
+  selectionRange: ComputedRef<CellRange | null>;
+  slots: ComputedRef<Map<string, SlotData>>;
+  columns: ComputedRef<ColumnDefinition[]>;
+  columnPositions: ComputedRef<number[]>;
+  rowHeight: number;
+}
+interface UseFillHandleResult {
+  fillHandlePosition: ComputedRef<{
+    top: number;
+    left: number;
+  } | null>;
+}
+/**
+ * Composable for calculating the fill handle position.
+ * The fill handle appears at the bottom-right corner of the selection
+ * when all selected columns are editable.
+ */
+declare function useFillHandle(options: UseFillHandleOptions): UseFillHandleResult;
+//#endregion
+//#region src/composables/useFilterPopup.d.ts
+interface UseFilterPopupOptions {
+  onClose: () => void;
+  ignoreSelector?: string;
+}
+/**
+ * Composable for filter popup behavior.
+ * Handles click-outside detection and escape key to close the popup.
+ */
+declare function useFilterPopup(popupRef: Ref<HTMLElement | null>, options: UseFilterPopupOptions): void;
+//#endregion
+//#region src/composables/useFilterConditions.d.ts
+interface LocalFilterCondition<TOperator extends string> {
+  operator: TOperator;
+  value: string;
+  valueTo: string;
+  nextOperator: "and" | "or";
+}
+interface UseFilterConditionsResult<TOperator extends string> {
+  conditions: Ref<LocalFilterCondition<TOperator>[]>;
+  combination: Ref<"and" | "or">;
+  updateCondition: (index: number, updates: Partial<LocalFilterCondition<TOperator>>) => void;
+  addCondition: (defaultOperator: TOperator) => void;
+  removeCondition: (index: number) => void;
+}
+/**
+ * Composable for managing filter conditions.
+ * Used by NumberFilterContent, DateFilterContent, and TextFilterContent (condition mode).
+ */
+declare function useFilterConditions<TOperator extends string>(initialConditions: LocalFilterCondition<TOperator>[], initialCombination?: "and" | "or"): UseFilterConditionsResult<TOperator>;
+//#endregion
+//#region src/gridState/useGridState.d.ts
+declare function createInitialState(): GridState;
+/**
+ * Vue composable for managing grid state
+ */
+declare function useGridState(): {
+  state: {
+    slots: Map<string, {
+      slotId: string;
+      rowIndex: number;
+      rowData: Row;
+      translateY: number;
+    }> & Omit<Map<string, SlotData>, keyof Map<any, any>>;
+    activeCell: {
+      row: number;
+      col: number;
+    } | null;
+    selectionRange: {
+      startRow: number;
+      startCol: number;
+      endRow: number;
+      endCol: number;
+    } | null;
+    editingCell: {
+      row: number;
+      col: number;
+      initialValue: CellValue;
+    } | null;
+    contentWidth: number;
+    contentHeight: number;
+    headers: Map<number, {
+      column: {
+        field: string;
+        colId?: string | undefined;
+        cellDataType: CellDataType;
+        width: number;
+        headerName?: string | undefined;
+        editable?: boolean | undefined;
+        sortable?: boolean | undefined;
+        filterable?: boolean | undefined;
+        cellRenderer?: string | undefined;
+        editRenderer?: string | undefined;
+        headerRenderer?: string | undefined;
+      };
+      sortDirection?: SortDirection | undefined;
+      sortIndex?: number | undefined;
+      sortable: boolean;
+      filterable: boolean;
+      hasFilter: boolean;
+    }> & Omit<Map<number, HeaderData>, keyof Map<any, any>>;
+    filterPopup: {
+      isOpen: boolean;
+      colIndex: number;
+      column: {
+        field: string;
+        colId?: string | undefined;
+        cellDataType: CellDataType;
+        width: number;
+        headerName?: string | undefined;
+        editable?: boolean | undefined;
+        sortable?: boolean | undefined;
+        filterable?: boolean | undefined;
+        cellRenderer?: string | undefined;
+        editRenderer?: string | undefined;
+        headerRenderer?: string | undefined;
+      } | null;
+      anchorRect: {
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+      } | null;
+      distinctValues: CellValue[];
+      currentFilter?: {
+        conditions: ({
+          type: "text";
+          operator: TextFilterOperator;
+          value?: string | undefined;
+          selectedValues?: (Set<string> & Omit<Set<string>, keyof Set<any>>) | undefined;
+          includeBlank?: boolean | undefined;
+          nextOperator?: FilterCombination | undefined;
+        } | {
+          type: "number";
+          operator: NumberFilterOperator;
+          value?: number | undefined;
+          valueTo?: number | undefined;
+          nextOperator?: FilterCombination | undefined;
+        } | {
+          type: "date";
+          operator: DateFilterOperator;
+          value?: (Date | string) | undefined;
+          valueTo?: (Date | string) | undefined;
+          nextOperator?: FilterCombination | undefined;
+        })[];
+        combination: FilterCombination;
+      } | undefined;
+    } | null;
+    isLoading: boolean;
+    error: string | null;
+    totalRows: number;
+    visibleRowRange: {
+      start: number;
+      end: number;
+    } | null;
+  };
+  applyInstructions: (instructions: GridInstruction[]) => void;
+  reset: () => void;
+};
+//#endregion
+//#region src/renderers/cellRenderer.d.ts
+/**
+ * Get cell value from row data, supporting dot-notation for nested fields
+ */
+declare function getCellValue(rowData: Row, field: string): CellValue;
+interface RenderCellOptions {
+  column: ColumnDefinition;
+  rowData: Row;
+  rowIndex: number;
+  colIndex: number;
+  isActive: boolean;
+  isSelected: boolean;
+  isEditing: boolean;
+  cellRenderers: Record<string, VueCellRenderer>;
+  globalCellRenderer?: VueCellRenderer;
+}
+/**
+ * Render cell content based on column configuration and renderer registries
+ */
+declare function renderCell(options: RenderCellOptions): VNode;
+//#endregion
+//#region src/renderers/editRenderer.d.ts
+interface RenderEditCellOptions {
+  column: ColumnDefinition;
+  rowData: Row;
+  rowIndex: number;
+  colIndex: number;
+  initialValue: CellValue;
+  core: GridCore | null;
+  editRenderers: Record<string, VueEditRenderer>;
+  globalEditRenderer?: VueEditRenderer;
+}
+/**
+ * Render edit cell content based on column configuration and renderer registries
+ */
+declare function renderEditCell(options: RenderEditCellOptions): VNode;
+//#endregion
+//#region src/renderers/headerRenderer.d.ts
+interface RenderHeaderOptions {
+  column: ColumnDefinition;
+  colIndex: number;
+  sortDirection?: SortDirection;
+  sortIndex?: number;
+  sortable: boolean;
+  filterable: boolean;
+  hasFilter: boolean;
+  core: GridCore | null;
+  container: HTMLDivElement | null;
+  headerRenderers: Record<string, VueHeaderRenderer>;
+  globalHeaderRenderer?: VueHeaderRenderer;
+}
+/**
+ * Render header content based on column configuration and renderer registries
+ */
+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, 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 };
+//# sourceMappingURL=index.d.ts.map