@ishibashi0112/spreadsheet-grid 0.34.0 → 0.35.0

package/dist/model/gridTypes.core.d.ts

@@ -0,0 +1,796 @@
+export type GridFrameworkTypes = {
+    node: unknown;
+    style: object;
+};
+export type GridRowKey = string | number;
+export type RowModel<T> = {
+    getRowCount: () => number;
+    getRow: (viewIndex: number) => T;
+    getSourceIndex: (viewIndex: number) => number;
+    getRowKey: (viewIndex: number) => GridRowKey;
+    getGroupRow?: (viewIndex: number) => GridGroupRow | undefined;
+};
+export type ServerSideQuery = {
+    globalText?: string;
+    columnFilters?: Record<string, ColumnFilterValue>;
+    sort?: GridSortState;
+};
+export type ServerSideGetRowsParams = {
+    startIndex: number;
+    endIndex: number;
+    query: ServerSideQuery;
+    signal: AbortSignal;
+};
+export type ServerSideGetRowsResult<T> = {
+    rows: T[];
+    totalRowCount: number;
+};
+export type ServerSideDataSource<T> = {
+    getRows: (params: ServerSideGetRowsParams) => Promise<ServerSideGetRowsResult<T>>;
+    updateRows?: (params: ServerSideUpdateRowsParams<T>) => Promise<ServerSideUpdateRowsResult<T> | void>;
+    initialRowCount?: number;
+    blockSize?: number;
+    maxCachedBlocks?: number;
+};
+export type ServerSideCellChange = {
+    columnKey: string;
+    previousValue: unknown;
+    newValue: unknown;
+};
+export type ServerSideRowUpdate<T> = {
+    rowKey: GridRowKey;
+    rowIndex: number;
+    row: T;
+    previousRow: T;
+    changes: ServerSideCellChange[];
+};
+export type ServerSideUpdateRowsParams<T> = {
+    updates: ServerSideRowUpdate<T>[];
+};
+export type ServerSideUpdateRowsResult<T> = {
+    rows?: T[];
+};
+export type ServerSideLoadErrorParams = {
+    startIndex: number;
+    endIndex: number;
+};
+export type ServerSideWriteErrorParams<T> = {
+    updates: ServerSideRowUpdate<T>[];
+};
+export type CellCoord = {
+    row: number;
+    col: number;
+};
+export type CellRange = {
+    start: CellCoord;
+    end: CellCoord;
+};
+export type UndoRedoState = {
+    canUndo: boolean;
+    canRedo: boolean;
+};
+export type GridSelection = {
+    type: 'cell';
+    range: CellRange;
+} | {
+    type: 'row';
+    startRow: number;
+    endRow: number;
+} | {
+    type: 'col';
+    startCol: number;
+    endCol: number;
+} | null;
+export type RowSelectionState = {
+    mode: 'include' | 'exclude';
+    keys: ReadonlySet<GridRowKey>;
+};
+export type RowSelectionModel = {
+    type: 'include';
+    rowKeys: GridRowKey[];
+} | {
+    type: 'exclude';
+    rowKeys: GridRowKey[];
+};
+export type RowSelectionMode = 'single' | 'multiple';
+export type SelectAllState = 'none' | 'some' | 'all';
+export type GridFilterState = {
+    globalText: string;
+    columnFilters: Record<string, ColumnFilterValue>;
+};
+export type GridSortDirection = 'asc' | 'desc' | null;
+export type GridSortEntry = {
+    columnKey: string;
+    direction: 'asc' | 'desc';
+};
+export type GridSortState = GridSortEntry[];
+export type GridSelectFilterOption = {
+    label: string;
+    value: string;
+};
+export type ColumnFilterUiType = 'text' | 'textSet' | 'number' | 'numberSet' | 'date' | 'dateSet' | 'select' | 'set' | 'custom';
+export type ColumnFilterTypeOption = ColumnFilterUiType | 'auto';
+export type SetColumnFilterValue = {
+    kind: 'set';
+    mode?: 'include' | 'exclude';
+    values: string[];
+};
+export type ParsedNumberFilter = {
+    mode: 'comparison';
+    operator: '>' | '>=' | '<' | '<=' | '=' | '!=';
+    value: number;
+} | {
+    mode: 'range';
+    min: number;
+    max: number;
+} | {
+    mode: 'blank';
+} | {
+    mode: 'notBlank';
+};
+export type NumberColumnFilterValue = {
+    kind: 'number';
+    raw: string;
+    parsed: ParsedNumberFilter | null;
+};
+export type TextColumnFilterValue = {
+    kind: 'text';
+    value: string;
+};
+export type DateColumnFilterValue = {
+    kind: 'date';
+    value: string;
+};
+export type NumberSetColumnFilterValue = {
+    kind: 'numberSet';
+    condition: ParsedNumberFilter | null;
+    set: {
+        mode?: 'include' | 'exclude';
+        values: string[];
+    } | null;
+};
+export type ParsedTextFilter = {
+    mode: 'contains' | 'equals' | 'startsWith' | 'endsWith';
+    value: string;
+} | {
+    mode: 'blank';
+} | {
+    mode: 'notBlank';
+};
+export type TextSetColumnFilterValue = {
+    kind: 'textSet';
+    condition: ParsedTextFilter | null;
+    set: {
+        mode?: 'include' | 'exclude';
+        values: string[];
+    } | null;
+};
+export type DateFilterPreset = 'today' | 'thisMonth' | 'last30days';
+export type DateFilterPresetRange = {
+    from?: string | Date;
+    to?: string | Date;
+};
+export type CustomDateFilterPreset = {
+    id: string;
+    label: string;
+    resolve: (now: Date) => DateFilterPresetRange;
+};
+export type DateFilterPresetOption = DateFilterPreset | CustomDateFilterPreset;
+export type FilterDateInputContext = {
+    value: string;
+    onChange: (value: string | Date | null) => void;
+    ariaLabel: string;
+    slot: 'single' | 'from' | 'to';
+    columnKey: string;
+};
+export type ParsedDateFilter = {
+    mode: 'range';
+    from: string;
+    to: string;
+} | {
+    mode: 'onOrAfter' | 'onOrBefore' | 'equals' | 'notEquals';
+    value: string;
+} | {
+    mode: 'blank';
+} | {
+    mode: 'notBlank';
+} | {
+    mode: 'preset';
+    preset: string;
+};
+export type DateSetColumnFilterValue = {
+    kind: 'dateSet';
+    condition: ParsedDateFilter | null;
+    set: {
+        mode?: 'include' | 'exclude';
+        values: string[];
+    } | null;
+};
+export type SelectColumnFilterValue = {
+    kind: 'select';
+    value: string;
+};
+export type CustomColumnFilterValue = {
+    kind: 'custom';
+    value: unknown;
+};
+export type ColumnFilterValue = SetColumnFilterValue | NumberColumnFilterValue | NumberSetColumnFilterValue | TextColumnFilterValue | TextSetColumnFilterValue | DateColumnFilterValue | DateSetColumnFilterValue | SelectColumnFilterValue | CustomColumnFilterValue;
+export type CellRenderContext<T, F extends GridFrameworkTypes = GridFrameworkTypes> = {
+    row: T;
+    rowIndex: number;
+    sourceRowIndex: number;
+    rowKey: GridRowKey;
+    colIndex: number;
+    value: unknown;
+    column: GridColumn<T, F>;
+    isActive: boolean;
+    isSelected: boolean;
+    isEditing: boolean;
+    readOnly: boolean;
+    setValue: (value: unknown) => void;
+    detail?: CellDetailContext;
+};
+export type CellDetailContext = {
+    expanded: boolean;
+    expandable: boolean;
+    toggle: () => void;
+    setExpanded: (expanded: boolean) => void;
+};
+export type DetailRowRenderContext<T> = {
+    row: T;
+    rowKey: GridRowKey;
+    rowIndex: number;
+    sourceRowIndex: number;
+    collapse: () => void;
+};
+export type DetailRowOptions<T, F extends GridFrameworkTypes = GridFrameworkTypes> = {
+    render: (ctx: DetailRowRenderContext<T>) => F['node'];
+    height?: number;
+    isExpandable?: (row: T, ctx: {
+        rowKey: GridRowKey;
+        sourceRowIndex: number;
+    }) => boolean;
+    showToggleColumn?: boolean;
+    className?: GridSlotProps<F>;
+};
+export type RowDragContext = {
+    rowKey: GridRowKey;
+    sourceRowIndex: number;
+};
+export type RowMoveParams<T> = {
+    rowKey: GridRowKey;
+    fromIndex: number;
+    toIndex: number;
+    rows: T[];
+};
+export type CellStyleContext<T, F extends GridFrameworkTypes = GridFrameworkTypes> = {
+    row: T;
+    rowIndex: number;
+    sourceRowIndex: number;
+    rowKey: GridRowKey;
+    colIndex: number;
+    value: unknown;
+    column: GridColumn<T, F>;
+    isActive: boolean;
+    isSelected: boolean;
+    isEditing: boolean;
+    readOnly: boolean;
+};
+export type RowStyleContext<T> = {
+    row: T;
+    rowIndex: number;
+    sourceRowIndex: number;
+    rowKey: GridRowKey;
+    isSelected: boolean;
+};
+export type CellRenderState = {
+    isActive: boolean;
+    isSelected: boolean;
+    isEditing: boolean;
+    readOnly: boolean;
+};
+export type HeaderRenderContext<T, F extends GridFrameworkTypes = GridFrameworkTypes> = {
+    colIndex: number;
+    width: number;
+    column: GridColumn<T, F>;
+    filterValue?: unknown;
+    isFiltered?: boolean;
+};
+export type GridColumnPinned = 'left' | 'right';
+export type CellValueFormatterParams<T, F extends GridFrameworkTypes = GridFrameworkTypes> = {
+    value: unknown;
+    row: T;
+    column: GridColumn<T, F>;
+};
+export type CellValueFormatter<T, F extends GridFrameworkTypes = GridFrameworkTypes> = (params: CellValueFormatterParams<T, F>) => string;
+export type EditorCommitDirection = 'down' | 'up' | 'right' | 'left';
+export type EditorEnterMove = 'down' | 'up' | 'right' | 'left' | 'none';
+export type GridSelectEditorOption = GridSelectFilterOption;
+export type GridColumnEditor<T, F extends GridFrameworkTypes = GridFrameworkTypes> = {
+    type: 'text';
+} | {
+    type: 'number';
+    min?: number;
+    max?: number;
+    step?: number;
+} | {
+    type: 'select';
+    options: GridSelectEditorOption[] | ((row: T) => GridSelectEditorOption[]);
+} | {
+    type: 'date';
+} | {
+    type: 'checkbox';
+    checkedValue?: unknown;
+    uncheckedValue?: unknown;
+} | {
+    type: 'custom';
+    render: (ctx: CellEditorContext<T, F>) => F['node'];
+};
+export type CellEditorContext<T, F extends GridFrameworkTypes = GridFrameworkTypes> = {
+    row: T;
+    rowIndex: number;
+    sourceRowIndex: number;
+    rowKey: GridRowKey;
+    colIndex: number;
+    column: GridColumn<T, F>;
+    value: unknown;
+    initialText: string;
+    align?: 'left' | 'center' | 'right';
+    commit: (value: unknown, direction?: EditorCommitDirection) => EditorCommitResult;
+    cancel: () => void;
+};
+export type GridValidationMode = 'mark' | 'reject';
+export type CellValidationContext<T, F extends GridFrameworkTypes = GridFrameworkTypes> = {
+    value: unknown;
+    row: T;
+    column: GridColumn<T, F>;
+};
+export type CellValidationResult = boolean | string | {
+    message: string;
+};
+export type GridInvalidCell = {
+    rowKey: GridRowKey;
+    sourceRowIndex: number;
+    columnKey: string;
+    message: string;
+};
+export type EditorCommitResult = {
+    status: 'committed';
+} | {
+    status: 'rejected';
+    message: string;
+} | {
+    status: 'noop';
+};
+export type GridAggFuncName = 'sum' | 'min' | 'max' | 'avg' | 'count';
+export type GridAggFuncParams<T, F extends GridFrameworkTypes = GridFrameworkTypes> = {
+    values: unknown[];
+    rows: T[];
+    column: GridColumn<T, F>;
+};
+export type GridAggFunc<T, F extends GridFrameworkTypes = GridFrameworkTypes> = (params: GridAggFuncParams<T, F>) => unknown;
+export type GridGroupRow = {
+    kind: 'group';
+    groupKey: string;
+    columnKey: string;
+    value: unknown;
+    label: string;
+    level: number;
+    leafCount: number;
+    aggregates: Record<string, unknown>;
+};
+export type GridColumn<T, F extends GridFrameworkTypes = GridFrameworkTypes> = {
+    key: string;
+    title?: string;
+    width: number;
+    minWidth?: number;
+    maxWidth?: number;
+    wordBreak?: 'normal' | 'break-all' | 'keep-all' | 'break-word' | 'auto-phrase';
+    lineBreak?: 'auto' | 'loose' | 'normal' | 'strict' | 'anywhere';
+    flex?: number;
+    resizable?: boolean;
+    suppressAutoSize?: boolean;
+    estimateCellWidth?: (row: T, column: GridColumn<T, F>) => number;
+    autoHeight?: boolean;
+    visible?: boolean;
+    editable?: boolean;
+    readOnly?: boolean;
+    pinned?: GridColumnPinned;
+    rowGroup?: boolean;
+    aggFunc?: GridAggFuncName | GridAggFunc<T, F>;
+    getValue?: (row: T) => unknown;
+    setValue?: (row: T, value: unknown) => T;
+    renderCell?: (ctx: CellRenderContext<T, F>) => F['node'];
+    cellClassName?: GridSlotProps<F> | ((ctx: CellStyleContext<T, F>) => GridSlotProps<F> | undefined);
+    align?: 'left' | 'center' | 'right';
+    valueFormatter?: CellValueFormatter<T, F>;
+    renderHeader?: (ctx: HeaderRenderContext<T, F>) => F['node'];
+    filterType?: ColumnFilterTypeOption;
+    filterOptions?: readonly GridSelectFilterOption[];
+    dateFilterPresets?: false | readonly DateFilterPresetOption[];
+    filterFn?: (row: T, filterValue: unknown) => boolean;
+    editor?: GridColumnEditor<T, F>;
+    validate?: (ctx: CellValidationContext<T, F>) => CellValidationResult;
+    validationMode?: GridValidationMode;
+    parseClipboardValue?: (raw: string, row: T) => unknown;
+    formatClipboardValue?: (value: unknown, row: T) => string;
+};
+export type ColumnResizeDragState = {
+    type: 'columnResize';
+    columnKey: string;
+    startX: number;
+    startWidth: number;
+    minWidth: number;
+    maxWidth: number;
+};
+export type CellSelectionDragState = {
+    type: 'selection';
+    selectionKind: 'cell';
+    anchor: CellCoord;
+};
+export type RowSelectionDragState = {
+    type: 'selection';
+    selectionKind: 'row';
+    anchorRow: number;
+};
+export type ColumnSelectionDragState = {
+    type: 'selection';
+    selectionKind: 'col';
+    anchorCol: number;
+};
+export type GridUiState = {
+    activeCell: CellCoord | null;
+    selection: GridSelection;
+    rowSelection: RowSelectionState;
+    editingCell: CellCoord | null;
+    dragState: CellSelectionDragState | RowSelectionDragState | ColumnSelectionDragState | ColumnResizeDragState | null;
+    columnWidths: Record<string, number>;
+    filters: GridFilterState;
+    sort: GridSortState;
+    collapsedGroupKeys: ReadonlySet<string>;
+    expandedDetailRowKeys: ReadonlySet<GridRowKey>;
+};
+export type SpreadsheetGridSelectionStats = {
+    selectedCellCount: number;
+    selectedRowCount: number;
+    selectedColumnCount: number;
+};
+export type SpreadsheetGridDerivedSummary = {
+    rowSummaryText: string;
+    columnSummaryText: string;
+    filterSummaryText: string;
+    sortSummaryText: string;
+    activeCellLabel: string;
+    selectionLabel: string;
+    selectionStatsText: string;
+    selectionStats: SpreadsheetGridSelectionStats;
+    hasGlobalFilter: boolean;
+    globalFilterPreview: string | null;
+    activeColumnFilterCount: number;
+    hasAnyFilter: boolean;
+    hasSorting: boolean;
+    sortedColumnLabel: string | null;
+};
+export type GlobalFilterStatus = 'idle' | 'filtering' | 'ready';
+export type SpreadsheetGridSlotContext<T, F extends GridFrameworkTypes = GridFrameworkTypes> = {
+    rows: T[];
+    filteredRows: T[];
+    columns: GridColumn<T, F>[];
+    visibleColumns: GridColumn<T, F>[];
+    globalFilterText: string;
+    columnFilterValues: Record<string, ColumnFilterValue>;
+    sortState: GridSortState;
+    setGlobalFilterText: (value: string) => void;
+    activeCell: CellCoord | null;
+    selection: GridSelection;
+    derivedSummary: SpreadsheetGridDerivedSummary;
+    globalFilterStatus: GlobalFilterStatus;
+    globalFilterProgress: number;
+};
+export type GridContextMenuTarget<T, F extends GridFrameworkTypes = GridFrameworkTypes> = {
+    type: 'cell';
+    rowIndex: number;
+    colIndex: number;
+    rowKey: GridRowKey;
+    row: T;
+    column: GridColumn<T, F>;
+    value: unknown;
+} | {
+    type: 'rowHeader';
+    rowIndex: number;
+    rowKey: GridRowKey;
+    row: T;
+};
+export type GridContextMenuParams<T, F extends GridFrameworkTypes = GridFrameworkTypes> = {
+    target: GridContextMenuTarget<T, F>;
+    clientX: number;
+    clientY: number;
+    selection: GridSelection;
+    activeCell: CellCoord | null;
+    isTargetSelected: boolean;
+};
+export type GridContextMenuActionItem<F extends GridFrameworkTypes = GridFrameworkTypes> = {
+    kind?: 'action';
+    id?: string;
+    label: F['node'];
+    icon?: F['node'];
+    disabled?: boolean;
+    danger?: boolean;
+    onSelect: () => void;
+};
+export type GridContextMenuLabelItem<F extends GridFrameworkTypes = GridFrameworkTypes> = {
+    kind: 'label';
+    id?: string;
+    label: F['node'];
+};
+export type GridContextMenuSeparatorItem = {
+    kind: 'separator';
+    id?: string;
+};
+export type GridContextMenuCustomItem<F extends GridFrameworkTypes = GridFrameworkTypes> = {
+    kind: 'custom';
+    id?: string;
+    render: (ctx: {
+        close: () => void;
+    }) => F['node'];
+};
+export type GridContextMenuItem<F extends GridFrameworkTypes = GridFrameworkTypes> = GridContextMenuActionItem<F> | GridContextMenuLabelItem<F> | GridContextMenuSeparatorItem | GridContextMenuCustomItem<F>;
+export type GridSlotProps<F extends GridFrameworkTypes = GridFrameworkTypes> = string | {
+    className?: string;
+    style?: F['style'];
+};
+export type GridResolvedSlot<F extends GridFrameworkTypes = GridFrameworkTypes> = {
+    className?: string;
+    style?: F['style'];
+};
+export type GridResolvedSlots<F extends GridFrameworkTypes = GridFrameworkTypes> = Partial<Record<keyof GridClassNames<F>, GridResolvedSlot<F>>>;
+export type GridClassNames<F extends GridFrameworkTypes = GridFrameworkTypes> = {
+    root?: GridSlotProps<F>;
+    toolbar?: GridSlotProps<F>;
+    statusBar?: GridSlotProps<F>;
+    headerRow?: GridSlotProps<F>;
+    headerCell?: GridSlotProps<F>;
+    bodyRow?: GridSlotProps<F>;
+    bodyCell?: GridSlotProps<F>;
+    rowHeaderCell?: GridSlotProps<F>;
+    iconButton?: GridSlotProps<F>;
+    cornerCell?: GridSlotProps<F>;
+    groupRow?: GridSlotProps<F>;
+    groupCell?: GridSlotProps<F>;
+    detailBand?: GridSlotProps<F>;
+    detailCard?: GridSlotProps<F>;
+    popover?: GridSlotProps<F>;
+    menuItem?: GridSlotProps<F>;
+    tooltip?: GridSlotProps<F>;
+    dragGhost?: GridSlotProps<F>;
+    checkbox?: GridSlotProps<F>;
+    cellEditor?: GridSlotProps<F>;
+    emptyState?: GridSlotProps<F>;
+    filterChipBar?: GridSlotProps<F>;
+    errorBar?: GridSlotProps<F>;
+    scrollHint?: GridSlotProps<F>;
+    activeCellOverlay?: GridSlotProps<F>;
+    selectionOverlay?: GridSlotProps<F>;
+};
+export type ScrollAlign = 'auto' | 'start' | 'center' | 'end';
+export type GridScrollPosition = {
+    top: number;
+    left: number;
+};
+export type GridScrollEventParams = {
+    top: number;
+    left: number;
+    source: 'user' | 'api';
+};
+/**
+ * エクスポートの対象範囲です(exportCsv / downloadCsv / getExportData で共通)。
+ * - `'view'`     : ビュー行全体(フィルター/ソート/列可視・固定順を反映)。**既定値**。スクロール位置に依存しません。
+ * - `'raw'`      : 全ソース行(`rows` 配列順)。フィルターもソートも無視します(列は可視列・固定順に従います)。
+ *                  serverSide はソース行配列を持たないため `'view'` 相当へフォールバックします(console.warn を出力)。
+ * - `'rendered'` : 仮想化ウィンドウ(いま描画中の行のみ・オーバースキャン込み)。結果はスクロール位置に依存します。
+ * - `'selection'`: 現在の選択範囲(セル/行/列)。選択なしのときは空(CSV は空文字 / データは空配列)を返します。
+ */
+export type CsvExportScope = 'view' | 'raw' | 'rendered' | 'selection' | DeprecatedCsvExportScope;
+/**
+ * 後方互換エイリアスです(実行時挙動は新名称と完全同一): `'all'` → `'view'` / `'visible'` → `'rendered'`。
+ * @deprecated `'visible'` は「フィルターで見えている行」ではなく「描画中の行(仮想化ウィンドウ)」を
+ *   指すため誤読のもとになります。新規コードでは `'view'` / `'rendered'` を使用してください。
+ */
+export type DeprecatedCsvExportScope = 'all' | 'visible';
+export type CsvExportOptions = {
+    scope?: CsvExportScope;
+    includeHeaders?: boolean;
+    delimiter?: string;
+    bom?: boolean;
+};
+export type GridExportOptions = {
+    scope?: CsvExportScope;
+};
+export type GridExportCell = {
+    value: unknown;
+    text: string;
+};
+export type GridExportData = {
+    columns: {
+        key: string;
+        title: string;
+    }[];
+    rows: GridExportCell[][];
+};
+export type GridColumnState = {
+    key: string;
+    visible?: boolean;
+    pinned?: GridColumnPinned;
+};
+export type GridState = {
+    version: number;
+    columnWidths: Record<string, number>;
+    filters: GridFilterState;
+    sort: GridSortState;
+    columns?: GridColumnState[];
+};
+export type SpreadsheetGridHandle<T> = {
+    scrollToRow: (viewRowIndex: number, options?: {
+        align?: ScrollAlign;
+    }) => void;
+    scrollToCell: (viewRowIndex: number, colIndex: number, options?: {
+        align?: ScrollAlign;
+    }) => void;
+    scrollToTop: () => void;
+    scrollToBottom: () => void;
+    getVisibleRowRange: () => {
+        startIndex: number;
+        endIndex: number;
+    } | null;
+    getScrollPosition: () => GridScrollPosition | null;
+    setScrollPosition: (position: {
+        top?: number;
+        left?: number;
+    }, options?: {
+        behavior?: 'auto' | 'smooth';
+    }) => void;
+    getActiveCell: () => CellCoord | null;
+    setActiveCell: (cell: CellCoord | null, options?: {
+        scrollIntoView?: boolean;
+    }) => void;
+    getSelection: () => GridSelection;
+    selectCell: (viewRowIndex: number, colIndex: number, options?: {
+        scrollIntoView?: boolean;
+    }) => void;
+    selectRange: (range: CellRange, options?: {
+        scrollIntoView?: boolean;
+    }) => void;
+    clearSelection: () => void;
+    getSelectedRows: () => T[];
+    exportCsv: (options?: CsvExportOptions) => string;
+    downloadCsv: (filename?: string, options?: CsvExportOptions) => void;
+    getExportData: (options?: GridExportOptions) => GridExportData;
+    getState: () => GridState;
+    applyState: (state: GridState) => void;
+    getRowSelection: () => RowSelectionModel;
+    setRowSelection: (model: RowSelectionModel) => void;
+    getSelectedRowKeys: () => GridRowKey[];
+    getSelectedRowData: () => T[];
+    getSelectedRowCount: () => number;
+    isRowSelected: (rowKey: GridRowKey) => boolean;
+    selectAllRows: () => void;
+    clearRowSelection: () => void;
+    undo: () => void;
+    redo: () => void;
+    canUndo: () => boolean;
+    canRedo: () => boolean;
+    clearUndoHistory: () => void;
+    setGroupCollapsed: (groupKey: string, collapsed: boolean) => void;
+    expandAllGroups: () => void;
+    collapseAllGroups: () => void;
+    getGroupRows: () => GridGroupRow[];
+    setDetailRowExpanded: (rowKey: GridRowKey, expanded: boolean) => void;
+    getExpandedDetailRowKeys: () => GridRowKey[];
+    collapseAllDetailRows: () => void;
+    moveRow: (rowKey: GridRowKey, toIndex: number) => void;
+    getInvalidCells: () => GridInvalidCell[];
+    refreshServerSide: () => void;
+    openFilterManager: () => void;
+    closeFilterManager: () => void;
+};
+export type GridDensity = 'compact' | 'standard' | 'comfortable';
+export type GridTheme = 'light' | 'dark' | 'auto';
+export type AutoSizeColumnsMode = 'onMount' | 'onDataChange' | false;
+export type ScrollHintTrigger = 'scroll' | 'hover' | 'always';
+export type ScrollHintRenderArgs<T> = {
+    rowIndex: number;
+    rowData: T | undefined;
+};
+export type ScrollHintOptions<T = unknown, F extends GridFrameworkTypes = GridFrameworkTypes> = {
+    bubble?: boolean;
+    ruler?: boolean;
+    scrollbar?: boolean;
+    trigger?: ScrollHintTrigger;
+    minRows?: number;
+    hintColumn?: string;
+    renderHint?: (args: ScrollHintRenderArgs<T>) => F['node'];
+};
+export type SpreadsheetGridProps<T, F extends GridFrameworkTypes = GridFrameworkTypes> = {
+    onStateChange?: (state: GridState) => void;
+    onScroll?: (params: GridScrollEventParams) => void;
+    rows?: readonly T[];
+    dataSource?: ServerSideDataSource<T>;
+    serverSideRefreshToken?: number;
+    onServerSideLoadError?: (error: unknown, params: ServerSideLoadErrorParams) => void;
+    onServerSideWriteError?: (error: unknown, params: ServerSideWriteErrorParams<T>) => void;
+    columns: readonly GridColumn<T, F>[];
+    onRowsChange?: (nextRows: T[]) => void;
+    onColumnsChange?: (nextColumns: GridColumn<T, F>[]) => void;
+    rowKeyGetter?: (row: T, index: number) => GridRowKey;
+    isRowExportable?: (row: T, ctx: {
+        viewRowIndex: number;
+        rowKey: GridRowKey;
+    }) => boolean;
+    createRow?: () => T;
+    createOverflowColumn?: (columnIndex: number) => GridColumn<T, F>;
+    rowHeight?: number;
+    autoHeight?: boolean;
+    estimateRowHeight?: number;
+    headerHeight?: number;
+    density?: GridDensity;
+    theme?: GridTheme;
+    rowHeaderWidth?: number;
+    height?: number | string;
+    maxHeight?: number | string;
+    readOnly?: boolean;
+    dimReadOnlyCells?: boolean;
+    canEditCell?: (rowIndex: number, colIndex: number, row: T, column: GridColumn<T, F>) => boolean;
+    enableUndoRedo?: boolean;
+    enableClearOnDelete?: boolean;
+    editorEnterMove?: EditorEnterMove;
+    undoHistoryLimit?: number;
+    onUndoRedoStateChange?: (state: UndoRedoState) => void;
+    enableRangeSelection?: boolean;
+    enableRowSelection?: boolean;
+    rowSelectionMode?: RowSelectionMode;
+    enableSelectAllRows?: boolean;
+    rowSelection?: RowSelectionModel;
+    selectedRowKeys?: GridRowKey[];
+    onRowSelectionChange?: (model: RowSelectionModel) => void;
+    enableGlobalFilter?: boolean;
+    enableColumnFilter?: boolean;
+    renderFilterDateInput?: (ctx: FilterDateInputContext) => F['node'];
+    enableSorting?: boolean;
+    enableColumnResize?: boolean;
+    autoSizeColumns?: AutoSizeColumnsMode;
+    showCellOverflowTooltip?: boolean;
+    showValidationMarks?: boolean;
+    enableRowHover?: boolean;
+    hoveredRowIndex?: number | null;
+    onHoveredRowChange?: (viewRowIndex: number | null, ctx: {
+        source: 'pointer';
+    }) => void;
+    enableColumnHeaderHover?: boolean;
+    enableColumnMenu?: boolean;
+    noMatchingRowsText?: string;
+    noRowsText?: string;
+    showTopBar?: boolean;
+    showTopBarSummary?: boolean;
+    showTopBarCounts?: boolean;
+    showTopBarFilter?: boolean;
+    globalFilterPlaceholder?: string;
+    globalFilterIcon?: F['node'];
+    showBottomBar?: boolean;
+    showBottomBarCounts?: boolean;
+    showFilterChipBar?: boolean;
+    renderTopBar?: (context: SpreadsheetGridSlotContext<T, F>) => F['node'];
+    renderBottomBar?: (context: SpreadsheetGridSlotContext<T, F>) => F['node'];
+    className?: string;
+    style?: F['style'];
+    classNames?: GridClassNames<F>;
+    getRowClassName?: (row: T, rowIndex: number, ctx: RowStyleContext<T>) => GridSlotProps<F> | undefined;
+    detailRow?: DetailRowOptions<T, F>;
+    onExpandedDetailRowKeysChange?: (keys: GridRowKey[]) => void;
+    enableRowDrag?: boolean;
+    isRowDraggable?: (row: T, ctx: RowDragContext) => boolean;
+    onRowMove?: (params: RowMoveParams<T>) => void;
+    enableContextMenu?: boolean;
+    getContextMenuItems?: (params: GridContextMenuParams<T, F>) => GridContextMenuItem<F>[];
+    onContextMenuOpen?: (params: GridContextMenuParams<T, F>) => void;
+    scrollHint?: boolean | ScrollHintOptions<T, F>;
+};