bolt-table 0.1.39 → 0.1.41

package/dist/index.d.mts

@@ -1,30 +1,32 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import React$1, { ReactNode, CSSProperties } from 'react';
+import React, { ReactNode, CSSProperties } from 'react';
 import { Virtualizer } from '@tanstack/react-virtual';
 
 /** Customizable icon overrides for BoltTable. */
 interface BoltTableIcons {
-    gripVertical?: React$1.ReactNode;
-    sortAsc?: React$1.ReactNode;
-    sortDesc?: React$1.ReactNode;
-    filter?: React$1.ReactNode;
-    filterClear?: React$1.ReactNode;
-    pin?: React$1.ReactNode;
-    pinOff?: React$1.ReactNode;
-    eyeOff?: React$1.ReactNode;
-    chevronDown?: React$1.ReactNode;
-    chevronLeft?: React$1.ReactNode;
-    chevronRight?: React$1.ReactNode;
-    chevronsLeft?: React$1.ReactNode;
-    chevronsRight?: React$1.ReactNode;
-    copy?: React$1.ReactNode;
-    edit?: React$1.ReactNode;
-    search?: React$1.ReactNode;
-    columns?: React$1.ReactNode;
-    close?: React$1.ReactNode;
-    sparkles?: React$1.ReactNode;
-    send?: React$1.ReactNode;
-    loader?: React$1.ReactNode;
+    gripVertical?: React.ReactNode;
+    sortAsc?: React.ReactNode;
+    sortDesc?: React.ReactNode;
+    filter?: React.ReactNode;
+    filterClear?: React.ReactNode;
+    pin?: React.ReactNode;
+    pinOff?: React.ReactNode;
+    eyeOff?: React.ReactNode;
+    chevronDown?: React.ReactNode;
+    chevronLeft?: React.ReactNode;
+    chevronRight?: React.ReactNode;
+    chevronsLeft?: React.ReactNode;
+    chevronsRight?: React.ReactNode;
+    copy?: React.ReactNode;
+    edit?: React.ReactNode;
+    search?: React.ReactNode;
+    columns?: React.ReactNode;
+    close?: React.ReactNode;
+    sparkles?: React.ReactNode;
+    send?: React.ReactNode;
+    loader?: React.ReactNode;
+    maximize?: React.ReactNode;
+    minimize?: React.ReactNode;
 }
 
 /** `'asc'` | `'desc'` | `null` — the direction of a column sort. */
@@ -52,6 +54,8 @@ interface ColumnType<T = unknown> {
     sorter?: boolean | ((a: T, b: T) => number);
     /** Whether this column shows a filter control. Defaults to `true`. */
     filterable?: boolean;
+    /** Type of filter UI to show. `"text"` (default) shows a text input, `"dateRange"` shows from/to date pickers, `"numberRange"` shows min/max number inputs. */
+    filterType?: "text" | "dateRange" | "numberRange";
     /**
      * Client-side filter predicate. Return `true` to keep the row.
      * Falls back to case-insensitive substring match when not provided.
@@ -80,6 +84,15 @@ interface ColumnType<T = unknown> {
     columnCellContextMenuItems?: CellContextMenuItem<T>[];
     /** When `true`, cells without a custom `render` become inline-editable on double-click. Requires the table-level `onEdit` callback. */
     editable?: boolean;
+    /** Type of editor to use for editable cells. Defaults to `"text"`. */
+    editorType?: "text" | "number" | "select" | "date" | "toggle";
+    /** Options for the `"select"` editor type. Array of `{ label, value }` or plain strings. */
+    editorOptions?: Array<string | {
+        label: string;
+        value: unknown;
+    }>;
+    /** Lazy data loader for this column. When provided, cell values are loaded asynchronously. Receives the row record and should return the cell value. */
+    lazyLoad?: (record: T) => Promise<unknown>;
     /** Nested child columns. When provided, this column acts as a header group and does not render data cells. Only leaf columns (without `children`) render cells. */
     children?: ColumnType<T>[];
 }
@@ -198,6 +211,53 @@ interface RowPinningConfig {
 }
 /** Base type for row records — all row objects must be indexable by string keys. */
 type DataRecord = Record<string, unknown>;
+/** Configuration for displaying data as a tree/hierarchy with parent-child relationships. */
+interface TreeDataConfig<T = unknown> {
+    /** Property name on each row that contains child rows. Defaults to `"children"`. */
+    childrenKey?: string;
+    /** Indentation width in pixels per nesting level. Defaults to `20`. */
+    indentSize?: number;
+    /** Row keys that are expanded by default. Omit to collapse all initially. */
+    defaultExpandedKeys?: React.Key[];
+    /** Controlled set of expanded tree node keys. */
+    expandedKeys?: React.Key[];
+    /** Called when tree expand state changes. */
+    onExpandChange?: (expandedKeys: React.Key[]) => void;
+    /** When true, all tree nodes are expanded by default. */
+    defaultExpandAll?: boolean;
+    /** Custom expand/collapse icon. Receives `(expanded, record, level)`. */
+    expandIcon?: (expanded: boolean, record: T, level: number) => React.ReactNode;
+}
+/** Aggregation function type for row grouping. */
+type AggregateFunction = "sum" | "avg" | "count" | "min" | "max" | ((values: unknown[]) => unknown);
+/** Configuration for grouping rows by a column value. */
+interface RowGroupingConfig<T = unknown> {
+    /** The column key to group rows by. */
+    groupBy: string;
+    /** Whether groups are collapsed by default. Defaults to `false`. */
+    defaultCollapsed?: boolean;
+    /** Controlled set of collapsed group keys. */
+    collapsedGroups?: Set<string>;
+    /** Called when a group's collapse state changes. */
+    onGroupToggle?: (groupKey: string, collapsed: boolean) => void;
+    /** Per-column aggregation functions shown in group header rows. Map of columnKey → aggregate function. */
+    aggregations?: Record<string, AggregateFunction>;
+    /** Custom render for the group header row. Receives group key, rows in group, and aggregate values. */
+    groupHeaderRender?: (groupKey: string, groupValue: unknown, rows: T[], aggregates: Record<string, unknown>, collapsed: boolean) => React.ReactNode;
+}
+/** A single declarative conditional formatting rule applied to cells or rows. */
+interface ConditionalFormatRule<T = unknown> {
+    /** Which column keys this rule applies to. Omit or pass empty to apply to all columns. */
+    columns?: string[];
+    /** Return `true` when the rule should activate. Receives `(value, record, columnKey)`. */
+    condition: (value: unknown, record: T, columnKey: string) => boolean;
+    /** Inline styles applied to matching cells (or rows when `applyToRow` is true). */
+    style?: React.CSSProperties;
+    /** CSS class name applied to matching cells (or rows when `applyToRow` is true). */
+    className?: string;
+    /** When true, the style/className applies to the entire row instead of individual cells. */
+    applyToRow?: boolean;
+}
 /** Configuration for persisting column state to localStorage. */
 interface ColumnPersistenceConfig {
     /** Unique key used as the localStorage key prefix. Required. */
@@ -309,6 +369,13 @@ interface BoltTableProps<T extends DataRecord = DataRecord> {
     readonly maxExpandedRowHeight?: number;
     /** Primary color for interactive elements (sort indicators, selected rows, checkboxes, etc.). */
     readonly accentColor?: string;
+    /**
+     * Color scheme hint for the table.
+     * - `"auto"` (default): inherits from the parent's computed `color-scheme` or the system preference.
+     * - `"dark"`: forces dark mode system colors and form controls.
+     * - `"light"`: forces light mode system colors and form controls.
+     */
+    readonly theme?: "auto" | "dark" | "light";
     /** Additional CSS class name applied to the outermost wrapper div. */
     readonly className?: string;
     /** Granular CSS class name overrides for specific parts of the table. */
@@ -316,7 +383,7 @@ interface BoltTableProps<T extends DataRecord = DataRecord> {
     /** Inline style overrides for specific parts of the table. */
     readonly styles?: StylesTypes;
     /** @deprecated Use `icons.gripVertical` instead. Custom drag grip icon for column headers. */
-    readonly gripIcon?: React$1.ReactNode;
+    readonly gripIcon?: React.ReactNode;
     /** Custom icon overrides for the table's built-in icons. */
     readonly icons?: BoltTableIcons;
     /** When true, the drag grip icon is hidden from all column headers. */
@@ -342,7 +409,7 @@ interface BoltTableProps<T extends DataRecord = DataRecord> {
     /** Row pinning configuration. Pass `true` for internal state management, or an object for controlled mode. */
     readonly rowPinning?: RowPinningConfig | boolean;
     /** Called when the user pins or unpins a row via the cell context menu. */
-    readonly onRowPin?: (rowKey: React$1.Key, pinned: "top" | "bottom" | false) => void;
+    readonly onRowPin?: (rowKey: React.Key, pinned: "top" | "bottom" | false) => void;
     /** Called when the user scrolls near the bottom of the table. Use for infinite scroll. */
     readonly onEndReached?: () => void;
     /** How many rows from the end of the list should trigger onEndReached. */
@@ -351,6 +418,13 @@ interface BoltTableProps<T extends DataRecord = DataRecord> {
     readonly isLoading?: boolean;
     /** Called when the user changes sort direction. Provide for server-side sorting. */
     readonly onSortChange?: (columnKey: string, direction: SortDirection) => void;
+    /** Enable sorting by multiple columns simultaneously. Hold Shift while clicking sort to add columns. */
+    readonly multiSort?: boolean;
+    /** Called when the multi-sort state changes. Receives the full ordered array of active sorts. Only fires when `multiSort` is true. */
+    readonly onMultiSortChange?: (sorts: ReadonlyArray<{
+        columnKey: string;
+        direction: SortDirection;
+    }>) => void;
     /** Called when the user applies or clears a column filter. Provide for server-side filtering. */
     readonly onFilterChange?: (filters: Record<string, string>) => void;
     /** Custom items to append to the column header right-click context menu. */
@@ -360,11 +434,21 @@ interface BoltTableProps<T extends DataRecord = DataRecord> {
     /** When true, renders a full shimmer skeleton layout before column widths are calculated. */
     readonly layoutLoading?: boolean;
     /** Custom React node to render when the table has no data and is not loading. */
-    readonly emptyRenderer?: React$1.ReactNode;
+    readonly emptyRenderer?: React.ReactNode;
+    /** Declarative conditional formatting rules. Each rule applies styles/classNames to cells or rows matching a condition. */
+    readonly conditionalFormatting?: ConditionalFormatRule<T>[];
+    /** Group rows by a column value, with collapsible headers and optional aggregations. */
+    readonly rowGrouping?: RowGroupingConfig<T>;
+    /** Display data as a tree hierarchy. Rows with a `children` array (or custom key) are shown as expandable tree nodes. */
+    readonly treeData?: TreeDataConfig<T>;
+    /** Show an advanced filter builder button in the toolbar. Allows building complex multi-condition filters visually. */
+    readonly enableFilterBuilder?: boolean;
+    /** Render a detail panel below the table when a row is clicked. Receives the clicked row record and a close function. */
+    readonly masterDetail?: (record: T, close: () => void) => React.ReactNode;
     /** Returns a CSS class name for a given row based on its record and index. Useful for Tailwind or any CSS class-based conditional row styling. */
     readonly rowClassName?: (record: T, index: number) => string;
     /** Returns inline CSS styles for a given row based on its record and index. Useful for dynamic per-row styling. */
-    readonly rowStyle?: (record: T, index: number) => React$1.CSSProperties;
+    readonly rowStyle?: (record: T, index: number) => React.CSSProperties;
     /** When true, removes the filter option from all header column context menus. */
     readonly disabledFilters?: boolean;
     /** Called after a cell value is copied to the clipboard via the context menu. */
@@ -374,7 +458,7 @@ interface BoltTableProps<T extends DataRecord = DataRecord> {
     /** Called when a user finishes editing an editable cell. Receives the new value, the row record, the column's `dataIndex`, and the row index. */
     readonly onEdit?: (value: unknown, record: T, dataIndex: string, rowIndex: number) => void;
     /** Called when a row is clicked. When provided, all row cells show a pointer cursor on hover. */
-    readonly onRowClick?: (record: T, index: number, event: React$1.MouseEvent) => void;
+    readonly onRowClick?: (record: T, index: number, event: React.MouseEvent) => void;
     /** Enable horizontal virtualization for tables with many columns. Only visible columns are rendered. */
     readonly enableColumnVirtualization?: boolean;
     /** Enable dynamic row heights based on content. Uses ResizeObserver to measure actual row heights. */
@@ -390,9 +474,11 @@ interface BoltTableProps<T extends DataRecord = DataRecord> {
     /** Called when the global search value changes. */
     readonly onGlobalSearchChange?: (value: string) => void;
     /** Extra content rendered in the toolbar between the search bar and the column-settings button. */
-    readonly toolbarContent?: React$1.ReactNode;
+    readonly toolbarContent?: React.ReactNode;
+    /** Extra content rendered on the right side of the toolbar, after all built-in buttons. */
+    readonly toolbarRight?: React.ReactNode;
     /** Label for the column-settings button. Defaults to "Columns". */
-    readonly columnSettingsLabel?: React$1.ReactNode;
+    readonly columnSettingsLabel?: React.ReactNode;
     /** Enable the AI assistant button in the toolbar. Requires `aiConfig` or `onAIQuery`. */
     readonly aiMode?: boolean;
     /** AI provider configuration (API key, model, etc.). Used by the built-in AI handler. */
@@ -407,13 +493,31 @@ interface BoltTableProps<T extends DataRecord = DataRecord> {
     /** Placeholder text for the AI search bar. */
     readonly aiPlaceholder?: string;
     /** Label for the AI button. Defaults to "Ask AI". */
-    readonly aiButtonLabel?: React$1.ReactNode;
+    readonly aiButtonLabel?: React.ReactNode;
+    /** Enable smooth CSS transitions on rows when data changes (sort, filter, reorder). Adds `transition: top` on cells. */
+    readonly enableRowAnimation?: boolean;
+    /** Show a status bar at the bottom of the table with row counts, selection info, etc. */
+    readonly showStatusBar?: boolean;
+    /** Custom renderer for the status bar. Receives `{ totalRows, filteredRows, selectedRows, currentPage, pageSize }`. When omitted, a default status bar is rendered. */
+    readonly statusBarContent?: (info: {
+        totalRows: number;
+        filteredRows: number;
+        selectedRows: number;
+        currentPage: number;
+        pageSize: number;
+    }) => React.ReactNode;
+    /** Called when the user clicks the "AI Insights" button. Should return a textual analysis of the data. Falls back to the built-in AI if not provided. */
+    readonly onAIInsights?: (data: T[], columns: ColumnType<T>[]) => Promise<string>;
+    /** Called when the user clicks the "AI Chart" button. Should return a React node with a chart visualization. When omitted and `aiConfig` is set, the built-in AI generates SVG chart markup. */
+    readonly onAIChart?: (data: T[], columns: ColumnType<T>[]) => Promise<React.ReactNode>;
     /** Enable row drag-and-drop reordering. When true, shows a grip handle on each row. Requires `onRowReorder`. */
     readonly rowDragEnabled?: boolean;
     /** Called when the user drops a row into a new position. Receives the old and new index. */
     readonly onRowReorder?: (fromIndex: number, toIndex: number) => void;
 }
 interface ClassNamesTypes {
+    /** Applied to the outermost wrapper div. */
+    wrapper?: string;
     /** Applied to all non-pinned column header cells. */
     header?: string;
     /** Applied to all body cells (both pinned and non-pinned). */
@@ -430,6 +534,22 @@ interface ClassNamesTypes {
     expandedRow?: string;
     /** Applied to each pinned row's wrapper div. */
     pinnedRow?: string;
+    /** Applied to the toolbar bar (search + buttons). */
+    toolbar?: string;
+    /** Applied to the global search input. */
+    searchInput?: string;
+    /** Applied to the status bar at the bottom. */
+    statusBar?: string;
+    /** Applied to the filter builder drawer. */
+    filterDrawer?: string;
+    /** Applied to the AI input/bar area. */
+    aiBar?: string;
+    /** Applied to the master-detail panel below the table. */
+    masterDetailPanel?: string;
+    /** Applied to group header rows (row grouping). */
+    groupHeader?: string;
+    /** Applied to the empty state container. */
+    emptyState?: string;
     /** Applied to the pagination footer wrapper. */
     pagination?: string;
     /** Applied to all pagination navigation buttons (first, prev, next, last). */
@@ -442,6 +562,8 @@ interface ClassNamesTypes {
     paginationInfo?: string;
 }
 interface StylesTypes {
+    /** Inline styles for the outermost wrapper div. */
+    wrapper?: CSSProperties;
     /** Inline styles for all non-pinned column header cells. */
     header?: CSSProperties;
     /** Inline styles for all body cells. */
@@ -468,6 +590,22 @@ interface StylesTypes {
     pinnedBg?: string;
     /** Inline styles applied to built-in context menu items (sort, filter, pin, copy, etc.). */
     contextMenuItem?: CSSProperties;
+    /** Inline styles for the toolbar bar (search + buttons). */
+    toolbar?: CSSProperties;
+    /** Inline styles for the global search input. */
+    searchInput?: CSSProperties;
+    /** Inline styles for the status bar at the bottom. */
+    statusBar?: CSSProperties;
+    /** Inline styles for the filter builder drawer. */
+    filterDrawer?: CSSProperties;
+    /** Inline styles for the AI input/bar area. */
+    aiBar?: CSSProperties;
+    /** Inline styles for the master-detail panel below the table. */
+    masterDetailPanel?: CSSProperties;
+    /** Inline styles for group header rows (row grouping). */
+    groupHeader?: CSSProperties;
+    /** Inline styles for the empty state container. */
+    emptyState?: CSSProperties;
     /** Inline styles for the pagination footer wrapper. */
     pagination?: CSSProperties;
     /** Inline styles for all pagination navigation buttons (first, prev, next, last). */
@@ -479,7 +617,7 @@ interface StylesTypes {
     /** Inline styles for the "X–Y of Z" info text. */
     paginationInfo?: CSSProperties;
 }
-declare function BoltTable<T extends DataRecord = DataRecord>({ columns: rawInitialColumns, data: rawData, rowHeight, expandedRowHeight, maxExpandedRowHeight, accentColor, className, classNames, styles, gripIcon, hideGripIcon, icons, pagination, onPaginationChange, onColumnResize, onColumnOrderChange, onColumnPin, onColumnHide, rowSelection, rowPinning, onRowPin, expandable, rowKey, onEndReached, onEndReachedThreshold, isLoading, onSortChange, onFilterChange, columnContextMenuItems, autoHeight, layoutLoading, emptyRenderer, rowClassName, rowStyle, disabledFilters, onCopy, keepPinnedRowsAcrossPages, onEdit, onRowClick, enableColumnVirtualization, enableDynamicRowHeight, columnPersistence, showColumnSettings, hideGlobalSearch, globalSearchValue, onGlobalSearchChange, toolbarContent, columnSettingsLabel, aiMode, aiConfig, onAIQuery, onAIResponse, aiPlaceholder, aiButtonLabel, rowDragEnabled, onRowReorder, }: BoltTableProps<T>): react_jsx_runtime.JSX.Element;
+declare function BoltTable<T extends DataRecord = DataRecord>({ columns: rawInitialColumns, data: rawData, rowHeight, expandedRowHeight, maxExpandedRowHeight, accentColor, theme, className, classNames, styles, gripIcon, hideGripIcon, icons, pagination, onPaginationChange, onColumnResize, onColumnOrderChange, onColumnPin, onColumnHide, rowSelection, rowPinning, onRowPin, expandable, rowKey, onEndReached, onEndReachedThreshold, isLoading, onSortChange, multiSort, onMultiSortChange, onFilterChange, columnContextMenuItems, autoHeight, layoutLoading, emptyRenderer, rowClassName, rowStyle, conditionalFormatting, rowGrouping, treeData, masterDetail, enableFilterBuilder, disabledFilters, onCopy, keepPinnedRowsAcrossPages, onEdit, onRowClick, enableColumnVirtualization, enableDynamicRowHeight, columnPersistence, showColumnSettings, hideGlobalSearch, globalSearchValue, onGlobalSearchChange, toolbarContent, toolbarRight, columnSettingsLabel, aiMode, aiConfig, onAIQuery, onAIResponse, aiPlaceholder, aiButtonLabel, onAIInsights, onAIChart, enableRowAnimation, showStatusBar, statusBarContent, rowDragEnabled, onRowReorder, }: BoltTableProps<T>): react_jsx_runtime.JSX.Element;
 
 interface DraggableHeaderProps {
     /** Column definition for this header cell. */
@@ -489,9 +627,9 @@ interface DraggableHeaderProps {
     /** Accent color for indicators and highlights. */
     accentColor?: string;
     /** Called when the user starts resizing this column. */
-    onResizeStart?: (columnKey: string, event: React$1.MouseEvent) => void;
+    onResizeStart?: (columnKey: string, event: React.MouseEvent) => void;
     /** Called when the user starts dragging this column header. */
-    onColumnDragStart?: (columnKey: string, event: React$1.PointerEvent) => void;
+    onColumnDragStart?: (columnKey: string, event: React.PointerEvent) => void;
     /** Shared styling overrides for header cells. */
     styles?: StylesTypes;
     /** Shared CSS class name overrides for header cells. */
@@ -499,7 +637,7 @@ interface DraggableHeaderProps {
     /** When true, the drag grip icon is hidden. */
     hideGripIcon?: boolean;
     /** Custom React node to use as the drag grip icon. */
-    gripIcon?: React$1.ReactNode;
+    gripIcon?: React.ReactNode;
     /** Pixel offset from the pinned edge for sticky positioning. */
     stickyOffset?: number;
     /** Called when the user pins or unpins this column. */
@@ -510,8 +648,10 @@ interface DraggableHeaderProps {
     isLastColumn?: boolean;
     /** Current sort direction applied to this column. */
     sortDirection?: SortDirection;
+    /** 1-based priority of this column in a multi-column sort. Undefined when not multi-sorting or column is not sorted. */
+    sortPriority?: number;
     /** Called when the user clicks a sort option in the context menu. */
-    onSort?: (columnKey: string, direction?: SortDirection) => void;
+    onSort?: (columnKey: string, direction?: SortDirection, additive?: boolean) => void;
     /** Current filter value active on this column. */
     filterValue?: string;
     /** Called when the user submits a filter value via the context menu. */
@@ -534,8 +674,10 @@ interface DraggableHeaderProps {
     isFirstColumn?: boolean;
     /** Called when the user double-clicks the resize handle to auto-fit column width. */
     onAutoFitColumn?: (columnKey: string) => void;
+    /** Whether the table is in dark mode — used for portalled elements that can't inherit wrapper styles. */
+    isDark?: boolean;
 }
-declare const DraggableHeader: React$1.MemoExoticComponent<({ column, visualIndex, accentColor, onResizeStart, styles, classNames, hideGripIcon, gripIcon, stickyOffset, onTogglePin, onToggleHide, isLastColumn, sortDirection, onSort, filterValue, onFilter, onClearFilter, customContextMenuItems, icons, onColumnDragStart, disabledFilters, headerGridRow, headerHeight, stickyTop, isFirstColumn, onAutoFitColumn, }: DraggableHeaderProps) => react_jsx_runtime.JSX.Element>;
+declare const DraggableHeader: React.MemoExoticComponent<({ column, visualIndex, accentColor, onResizeStart, styles, classNames, hideGripIcon, gripIcon, stickyOffset, onTogglePin, onToggleHide, isLastColumn, sortDirection, sortPriority, onSort, filterValue, onFilter, onClearFilter, customContextMenuItems, icons, onColumnDragStart, disabledFilters, headerGridRow, headerHeight, stickyTop, isFirstColumn, onAutoFitColumn, isDark, }: DraggableHeaderProps) => react_jsx_runtime.JSX.Element>;
 
 interface ResizeOverlayHandle {
     show: (viewportX: number, columnName: string, areaRect: DOMRect, headerLeftLocal: number, minSize: number, scrollTop: number, scrollLeft: number, initialLineX: number) => void;
@@ -546,7 +688,7 @@ interface ResizeOverlayProps {
     /** @default '#1778ff' */
     accentColor?: string;
 }
-declare const ResizeOverlay: React$1.ForwardRefExoticComponent<ResizeOverlayProps & React$1.RefAttributes<ResizeOverlayHandle>>;
+declare const ResizeOverlay: React.ForwardRefExoticComponent<ResizeOverlayProps & React.RefAttributes<ResizeOverlayHandle>>;
 
 interface TableBodyProps {
     /** Current page's row data */
@@ -568,11 +710,11 @@ interface TableBodyProps {
     /** Returns the string key for a given row record and index */
     getRowKey?: (record: DataRecord, index: number) => string;
     /** Returns the original-typed key for a given row record and index */
-    getRawRowKey?: (record: DataRecord, index: number) => React$1.Key;
+    getRawRowKey?: (record: DataRecord, index: number) => React.Key;
     /** Expandable row configuration */
     expandable?: ExpandableConfig<DataRecord>;
     /** Set of currently expanded row keys */
-    resolvedExpandedKeys?: Set<React$1.Key>;
+    resolvedExpandedKeys?: Set<React.Key>;
     /** Height of each regular row in pixels */
     rowHeight?: number;
     /** Total pixel width of all columns combined */
@@ -582,7 +724,7 @@ interface TableBodyProps {
     /** Accent color for the expand toggle button */
     accentColor?: string;
     /** Ref to the scroll container element */
-    scrollContainerRef?: React$1.RefObject<HTMLDivElement | null>;
+    scrollContainerRef?: React.RefObject<HTMLDivElement | null>;
     /** When true, cells render as shimmer skeletons */
     isLoading?: boolean;
     /** Called when an expanded row's content height changes */
@@ -600,7 +742,7 @@ interface TableBodyProps {
     /** Returns a CSS class name for a given row based on its record and index */
     rowClassName?: (record: DataRecord, index: number) => string;
     /** Returns inline CSS styles for a given row based on its record and index */
-    rowStyle?: (record: DataRecord, index: number) => React$1.CSSProperties;
+    rowStyle?: (record: DataRecord, index: number) => React.CSSProperties;
     /** CSS grid row index for the body area. Defaults to 2. Set to 3 when column groups add an extra header row. */
     bodyGridRow?: number;
     /** Called when a user finishes editing an editable cell. */
@@ -619,10 +761,25 @@ interface TableBodyProps {
     /** Maps column key → 1-based CSS grid column index in the full (non-virtualized) grid. Required for correct placement when column virtualization is enabled. */
     columnGridIndexMap?: Map<string, number>;
     /** Optional AI cell style function. Returns extra styles for a specific cell. */
-    cellStyleFn?: (record: DataRecord, columnKey: string) => React$1.CSSProperties | undefined;
+    cellStyleFn?: (record: DataRecord, columnKey: string) => React.CSSProperties | undefined;
     /** Called when the user starts dragging a row by its grip handle. */
-    onRowDragStart?: (rowIndex: number, e: React$1.PointerEvent) => void;
+    onRowDragStart?: (rowIndex: number, e: React.PointerEvent) => void;
+    /** Currently focused cell coordinates for keyboard navigation. */
+    focusedCell?: {
+        row: number;
+        col: number;
+    } | null;
+    /** Enable row position animation on data changes. */
+    enableRowAnimation?: boolean;
+    /** Called when a group header is clicked to toggle collapse. */
+    onGroupToggle?: (groupKey: string) => void;
+    /** Accent color for group headers. */
+    groupAccentColor?: string;
+    /** Called when a tree node expand/collapse is toggled. */
+    onTreeToggle?: (key: React.Key) => void;
+    /** Tree data indent size in pixels per level. */
+    treeIndentSize?: number;
 }
-declare const TableBody: React$1.FC<TableBodyProps>;
+declare const TableBody: React.FC<TableBodyProps>;
 
-export { type AICellStyleOperation, type AIColumnVisibilityOperation, type AICondition, type AIFilterOperation, type AIOperation, type AIOperator, type AIPinColumnOperation, type AIReorderColumnsOperation, type AIResizeColumnOperation, type AIResponse, type AISetPageOperation, type AISortOperation, type AIStyleOperation, BoltTable, type BoltTableAIConfig, type BoltTableConfig, type BoltTableIcons, type CellContextMenuItem, type ClassNamesTypes, type ColumnContextMenuItem, type ColumnPersistenceConfig, type ColumnType, type DataRecord, DraggableHeader, type ExpandableConfig, type PaginationType, ResizeOverlay, type RowPinningConfig, type RowSelectionConfig, type SortDirection, type StylesTypes, TableBody, defineConfig };
+export { type AICellStyleOperation, type AIColumnVisibilityOperation, type AICondition, type AIFilterOperation, type AIOperation, type AIOperator, type AIPinColumnOperation, type AIReorderColumnsOperation, type AIResizeColumnOperation, type AIResponse, type AISetPageOperation, type AISortOperation, type AIStyleOperation, type AggregateFunction, BoltTable, type BoltTableAIConfig, type BoltTableConfig, type BoltTableIcons, type CellContextMenuItem, type ClassNamesTypes, type ColumnContextMenuItem, type ColumnPersistenceConfig, type ColumnType, type ConditionalFormatRule, type DataRecord, DraggableHeader, type ExpandableConfig, type PaginationType, ResizeOverlay, type RowGroupingConfig, type RowPinningConfig, type RowSelectionConfig, type SortDirection, type StylesTypes, TableBody, type TreeDataConfig, defineConfig };