@zvndev/yable-react 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,957 @@
+import { Table as Table$1, RowData, Cell, Header, Row, TableOptions, ColumnDef, SortDirection, CellContext, ClipboardOptions, CellFlashInfo } from '@zvndev/yable-core';
+export { AccessorFnColumnDef, AccessorKeyColumnDef, AggregationFn, Cell, CellStatus as CellCommitStatus, CellContext, CellFlashEvent, CellPatch, ClipboardOptions, Column, ColumnDef, ColumnDefBase, ColumnFiltersState, ColumnMeta, ColumnOrderState, ColumnPinningState, ColumnSizingInfoState, ColumnSizingState, CommitError, CommitErrorCells, CommitRecord, CommitResult, CommitsSlice, DisplayColumnDef, EditingState, ExpandedState, FillHandleState, FilterFn, FormulaState, GroupColumnDef, Header, HeaderContext, HeaderGroup, KeyboardNavigationAction, KeyboardNavigationCell, KeyboardNavigationDirection, KeyboardNavigationState, OnChangeFn, OnCommitFn, PaginationState, PartialLocale, PivotConfig, PivotState, Row, RowData, RowDragEndEvent, RowDragEvent, RowDragState, RowEditCommitEvent, RowEditEvent, RowPinningState, RowReorderEvent, RowSelectionState, SortDirection, SortingFn, SortingState, Table as TableInstance, TableOptions, TableOptionsResolved, TableState, UndoAction, UndoRedoState, Updater, VisibilityState, YableLocale, aggregationFns, createColumnHelper, createLocale, en, filterFns, functionalUpdate, getDefaultLocale, resetLocale, setDefaultLocale, sortingFns } from '@zvndev/yable-core';
+import * as React$1 from 'react';
+import React__default, { HTMLAttributes, TdHTMLAttributes, ThHTMLAttributes } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { RowDragState } from '@zvndev/yable-core/features/rowDragging';
+
+interface TableProps<TData extends RowData> extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    table: Table$1<TData>;
+    /** Enable sticky header */
+    stickyHeader?: boolean;
+    /** Enable striped rows */
+    striped?: boolean;
+    /** Enable bordered cells */
+    bordered?: boolean;
+    /** Enable compact spacing */
+    compact?: boolean;
+    /** Theme variant */
+    theme?: string;
+    /** Whether rows are clickable (adds cursor + hover) */
+    clickableRows?: boolean;
+    /** Show footer */
+    footer?: boolean;
+    /** Loading state */
+    loading?: boolean;
+    /** Custom loading component */
+    loadingComponent?: React.ReactNode;
+    /** Loading text shown below the spinner */
+    loadingText?: string;
+    /** Empty state message */
+    emptyMessage?: string;
+    /** Custom empty state render */
+    renderEmpty?: () => React.ReactNode;
+    /** Custom loading render */
+    renderLoading?: () => React.ReactNode;
+    /** Custom empty component */
+    emptyComponent?: React.ReactNode;
+    /** Custom empty icon */
+    emptyIcon?: React.ReactNode;
+    /** Secondary detail text for empty state */
+    emptyDetail?: string;
+    /** Children rendered inside the table container (e.g. Pagination) */
+    children?: React.ReactNode;
+    /** Text direction for RTL support */
+    direction?: 'ltr' | 'rtl';
+    /** Enable status bar */
+    statusBar?: boolean;
+    /** Status bar panels configuration */
+    statusBarPanels?: StatusBarPanelConfig[];
+    /** Enable sidebar */
+    sidebar?: boolean;
+    /** Sidebar panels */
+    sidebarPanels?: ('columns' | 'filters')[];
+    /** Default sidebar panel */
+    defaultSidebarPanel?: 'columns' | 'filters';
+}
+/** Status bar panel configuration */
+interface StatusBarPanelConfig {
+    id: string;
+    component?: React.ComponentType<StatusBarPanelProps>;
+    align?: 'left' | 'center' | 'right';
+    label?: string;
+}
+/** Props passed to status bar panel components */
+interface StatusBarPanelProps {
+    table: Table$1<any>;
+}
+interface TableRowProps<TData extends RowData> extends HTMLAttributes<HTMLTableRowElement> {
+    row: Row<TData>;
+}
+interface TableCellProps$1<TData extends RowData, TValue = unknown> extends TdHTMLAttributes<HTMLTableCellElement> {
+    cell: Cell<TData, TValue>;
+}
+interface TableHeaderCellProps<TData extends RowData, TValue = unknown> extends ThHTMLAttributes<HTMLTableCellElement> {
+    header: Header<TData, TValue>;
+}
+
+declare function useTable<TData extends RowData>(options: TableOptions<TData>): Table$1<TData>;
+
+interface VirtualRow {
+    index: number;
+    start: number;
+    size: number;
+}
+interface UseVirtualizationOptions {
+    containerRef: React.RefObject<HTMLElement | null>;
+    totalRows: number;
+    rowHeight?: number | ((index: number) => number);
+    overscan?: number;
+    estimateRowHeight?: number;
+    /** Pre-computed row heights from Pretext measurement (Float64Array indexed by row) */
+    pretextHeights?: Float64Array | null;
+    /** Pre-computed prefix sums for O(log n) scroll lookups */
+    pretextPrefixSums?: Float64Array | null;
+}
+interface UseVirtualizationResult {
+    virtualRows: VirtualRow[];
+    totalHeight: number;
+    startIndex: number;
+    endIndex: number;
+    scrollTo: (index: number) => void;
+}
+/**
+ * Computes which rows are visible in a scrollable container and returns
+ * positioning data so only those rows (plus an overscan buffer) are rendered.
+ *
+ * Supports both fixed and variable row heights.
+ */
+declare function useVirtualization({ containerRef, totalRows, rowHeight, overscan, estimateRowHeight: _estimateRowHeight, pretextHeights, pretextPrefixSums, }: UseVirtualizationOptions): UseVirtualizationResult;
+
+interface CellMeasurement {
+    /** Column ID */
+    columnId: string;
+    /** Column width in px */
+    width: number;
+    /** CSS font string for this column, e.g. "400 13px Inter" */
+    font: string;
+    /** Line height in px */
+    lineHeight: number;
+    /** Vertical padding in px (top + bottom) */
+    padding?: number;
+    /**
+     * If true, this column never wraps text — Pretext skips text measurement
+     * for it and contributes a constant `lineHeight + padding` to every row.
+     * Use this for visual cells like progress bars and rating stars.
+     */
+    fixedHeight?: boolean;
+}
+interface UsePretextMeasurementOptions {
+    /** The row data to measure */
+    data: any[];
+    /** Measurement config per column — only columns that need text measurement */
+    columns: CellMeasurement[];
+    /** Extract the text content for a given row and column */
+    getCellText: (row: any, columnId: string) => string;
+    /** Minimum row height in px */
+    minRowHeight?: number;
+    /** Whether measurement is enabled */
+    enabled?: boolean;
+}
+interface UsePretextMeasurementResult {
+    /** Map from row index → exact pixel height */
+    rowHeights: Float64Array | null;
+    /** Pre-computed cumulative offsets for binary search (prefix sums) */
+    prefixSums: Float64Array | null;
+    /** Total height of all rows in px */
+    totalHeight: number;
+    /** Whether pretext is loaded and heights are computed */
+    ready: boolean;
+    /** Time taken for prepare() phase in ms */
+    prepareTimeMs: number;
+    /** Time taken for layout() phase in ms */
+    layoutTimeMs: number;
+}
+/**
+ * Pre-computes exact pixel heights for every row using Pretext's
+ * DOM-free text measurement. Returns typed arrays for cache-friendly
+ * access by the virtualizer.
+ *
+ * layout() is pure arithmetic (~0.0003ms per cell) so column resizing
+ * re-computes all heights near-instantly.
+ */
+declare function usePretextMeasurement({ data, columns, getCellText, minRowHeight, enabled, }: UsePretextMeasurementOptions): UsePretextMeasurementResult;
+
+/** Font measurement recipe for a cell type, used by Pretext integration */
+interface CellMeasureRecipe {
+    /** CSS font string, e.g. "500 13px Inter" */
+    font: string;
+    /** Line height in px */
+    lineHeight: number;
+    /** Cell padding (top + bottom) in px */
+    padding: number;
+    /**
+     * If true, the cell renders at a fixed visual height regardless of text content
+     * (e.g. progress bar, rating stars). Pretext will return `lineHeight + padding`
+     * as the row contribution and skip text measurement entirely.
+     */
+    fixedHeight?: boolean;
+}
+/** Base props shared by all display cell types */
+interface CellTypeBaseProps {
+    /** Additional CSS class */
+    className?: string;
+}
+/** Badge / pill cell — categorical data like departments, tags */
+interface CellBadgeProps extends CellTypeBaseProps {
+    /** Color variant — maps to theme tokens */
+    variant?: 'default' | 'accent' | 'success' | 'warning' | 'danger' | 'info';
+    /** Visual style */
+    appearance?: 'soft' | 'solid' | 'outline';
+}
+/** Currency / money cell — formatted numbers with currency symbol */
+interface CellCurrencyProps extends CellTypeBaseProps {
+    /** ISO 4217 currency code */
+    currency?: string;
+    /** Locale for formatting */
+    locale?: string;
+    /** Number of decimal places (default: 0 for integers, 2 for decimals) */
+    decimals?: number;
+    /** Show +/- coloring for positive/negative values */
+    colorize?: boolean;
+}
+/** Status indicator cell — dot + label for states */
+interface CellStatusProps extends CellTypeBaseProps {
+    /** Map of value → color variant */
+    colorMap?: Record<string, 'success' | 'warning' | 'danger' | 'info' | 'default'>;
+}
+/** Numeric cell — right-aligned, tabular numbers */
+interface CellNumericProps extends CellTypeBaseProps {
+    /** Locale for formatting */
+    locale?: string;
+    /** Unit suffix (e.g. "ms", "KB", "%") */
+    unit?: string;
+    /** Number of decimal places */
+    decimals?: number;
+    /** Show +/- coloring */
+    colorize?: boolean;
+}
+/** Rating cell — star or dot display */
+interface CellRatingProps extends CellTypeBaseProps {
+    /** Maximum rating value (default: 5) */
+    max?: number;
+    /** Display character (default: "★") */
+    character?: string;
+    /** Empty character (default: "☆") */
+    emptyCharacter?: string;
+}
+/** Boolean cell — visual true/false indicator */
+interface CellBooleanProps extends CellTypeBaseProps {
+    /** Label for true value */
+    trueLabel?: string;
+    /** Label for false value */
+    falseLabel?: string;
+    /** Display mode */
+    mode?: 'dot' | 'badge' | 'icon';
+}
+/** Progress cell — inline progress bar */
+interface CellProgressProps extends CellTypeBaseProps {
+    /** Maximum value (default: 100) */
+    max?: number;
+    /** Color variant */
+    variant?: 'default' | 'accent' | 'success' | 'warning' | 'danger';
+    /** Show percentage label */
+    showLabel?: boolean;
+}
+/** Link cell — clickable URL or text */
+interface CellLinkProps extends CellTypeBaseProps {
+    /** URL to link to (if not the cell value itself) */
+    href?: string | ((value: unknown) => string);
+    /** Open in new tab */
+    external?: boolean;
+}
+/** Date cell — formatted dates */
+interface CellDateProps extends CellTypeBaseProps {
+    /** Intl.DateTimeFormat options or preset name */
+    format?: 'short' | 'medium' | 'long' | 'relative' | Intl.DateTimeFormatOptions;
+    /** Locale for formatting */
+    locale?: string;
+}
+
+interface AutoMeasurementsOptions<TData extends RowData> {
+    /** Columns to measure — usually the same array passed into `useTable`. */
+    columns: ColumnDef<TData, any>[];
+    /**
+     * Default recipe for columns that don't declare a `cellType` or
+     * `measureRecipe`. This is the theme's body text style.
+     */
+    defaultRecipe: CellMeasureRecipe;
+    /**
+     * Override how a column's pixel width is determined. Defaults to
+     * `column.size ?? 150`. Provide this when you want auto-measurement to
+     * track live column resizing — e.g. `(col) => table.getColumn(col.id)?.getSize() ?? 150`.
+     */
+    getColumnWidth?: (column: ColumnDef<TData, any>) => number;
+    /**
+     * Optional filter — return false to skip a column entirely (e.g. select
+     * checkboxes, action buttons). Defaults to skipping columns whose id
+     * starts with `_` or matches common non-data ids.
+     */
+    shouldMeasureColumn?: (column: ColumnDef<TData, any>) => boolean;
+}
+/**
+ * Resolve the measure recipe for a single column, walking the precedence
+ * chain (per-column override → cellType built-in → default).
+ */
+declare function resolveMeasureRecipe<TData extends RowData>(column: ColumnDef<TData, any>, defaultRecipe: CellMeasureRecipe): CellMeasureRecipe;
+/**
+ * Build a `CellMeasurement[]` from columns, suitable for handing to
+ * `usePretextMeasurement`. Pure derivation — no table instance required.
+ */
+declare function useAutoMeasurements<TData extends RowData>({ columns, defaultRecipe, getColumnWidth, shouldMeasureColumn, }: AutoMeasurementsOptions<TData>): CellMeasurement[];
+
+interface UseTableRowHeightsOptions<TData extends RowData> {
+    /** Row data being measured. */
+    data: TData[];
+    /** Column definitions (the same array passed into `useTable`). */
+    columns: ColumnDef<TData, any>[];
+    /**
+     * Default text recipe for columns without an explicit `cellType` /
+     * `measureRecipe`. Should reflect the active theme's body text style.
+     */
+    defaultRecipe?: CellMeasureRecipe;
+    /**
+     * Override how a column's pixel width is determined. Defaults to
+     * `column.size ?? 150`. Provide this when you want pretext to track
+     * live column resizing — e.g. `(c) => table.getColumn(c.id)?.getSize() ?? 150`.
+     */
+    getColumnWidth?: (column: ColumnDef<TData, any>) => number;
+    /** Minimum row height in px (default: 36). */
+    minRowHeight?: number;
+    /** Disable measurement entirely (e.g. when virtualization is off). */
+    enabled?: boolean;
+}
+/** Sensible default that matches `@zvndev/yable-themes` `tokens.css`. */
+declare const DEFAULT_TEXT_RECIPE: CellMeasureRecipe;
+/**
+ * Compute exact pixel row heights for the entire dataset using Pretext,
+ * deriving per-column measurement specs from each column's declarative
+ * `cellType` (or explicit `measureRecipe` override). No font strings,
+ * line heights, or paddings to hand-write.
+ *
+ * Returns the same shape as `usePretextMeasurement` plus the resolved
+ * `measurements` array for debugging / inspection.
+ */
+declare function useTableRowHeights<TData extends RowData>({ data, columns, defaultRecipe, getColumnWidth, minRowHeight, enabled, }: UseTableRowHeightsOptions<TData>): UsePretextMeasurementResult & {
+    measurements: CellMeasurement[];
+};
+
+/**
+ * Look up the measure recipe for a built-in cell type. Returns `undefined`
+ * for unknown types so callers can fall back to a default text recipe.
+ */
+declare function getMeasureRecipeForCellType(cellType: string): CellMeasureRecipe | undefined;
+/** Read-only access to the registered cell type ids — useful for tooling. */
+declare function getRegisteredCellTypes(): readonly string[];
+
+declare const TableProvider: React$1.Provider<Table$1<any> | null>;
+declare function useTableContext<TData extends RowData>(): Table$1<TData>;
+
+declare function Table<TData extends RowData>({ table, stickyHeader, striped, bordered, compact, theme, clickableRows, footer, loading, loadingComponent, loadingText, emptyMessage, emptyComponent, emptyIcon, emptyDetail, renderEmpty, renderLoading, children, className, direction, statusBar, statusBarPanels, sidebar, sidebarPanels, defaultSidebarPanel, ...rest }: TableProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface TableHeaderProps<TData extends RowData> {
+    table: Table$1<TData>;
+}
+declare function TableHeader<TData extends RowData>({ table, }: TableHeaderProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface TableBodyProps<TData extends RowData> {
+    table: Table$1<TData>;
+    clickableRows?: boolean;
+}
+declare function TableBody<TData extends RowData>({ table, clickableRows, }: TableBodyProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface TableCellProps<TData extends RowData> {
+    cell: Cell<TData, unknown>;
+    table: Table$1<TData>;
+    rowIndex: number;
+    columnIndex: number;
+    isFocused: boolean;
+    isTabStop: boolean;
+}
+declare function TableCell<TData extends RowData>({ cell, table, rowIndex, columnIndex, isFocused, isTabStop, }: TableCellProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface TableFooterProps<TData extends RowData> {
+    table: Table$1<TData>;
+}
+declare function TableFooter<TData extends RowData>({ table, }: TableFooterProps<TData>): react_jsx_runtime.JSX.Element | null;
+
+interface PaginationProps<TData extends RowData> {
+    table: Table$1<TData>;
+    /** Show page size selector */
+    showPageSize?: boolean;
+    /** Available page sizes */
+    pageSizes?: number[];
+    /** Show row count info */
+    showInfo?: boolean;
+    /** Show first/last buttons */
+    showFirstLast?: boolean;
+}
+declare function Pagination<TData extends RowData>({ table, showPageSize, pageSizes, showInfo, showFirstLast, }: PaginationProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface GlobalFilterProps<TData extends RowData> {
+    table: Table$1<TData>;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Debounce delay in ms (0 = no debounce) */
+    debounce?: number;
+    /** Custom class name */
+    className?: string;
+}
+declare function GlobalFilter<TData extends RowData>({ table, placeholder, debounce, className, }: GlobalFilterProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface SortIndicatorProps {
+    direction: SortDirection | false;
+    index?: number;
+}
+declare function SortIndicator({ direction, index }: SortIndicatorProps): react_jsx_runtime.JSX.Element;
+
+interface ErrorBoundaryProps {
+    /** Callback fired when an error is caught */
+    onError?: (error: Error, errorInfo: React__default.ErrorInfo) => void;
+    /** When any value in this array changes, the boundary resets */
+    resetKeys?: unknown[];
+    /** Custom fallback to render when an error is caught */
+    fallback?: React__default.ReactNode;
+    children: React__default.ReactNode;
+}
+interface ErrorBoundaryState {
+    hasError: boolean;
+    error: Error | null;
+}
+/**
+ * Catches rendering errors in child components so one bad cell or row
+ * does not crash the entire table. Logs errors and provides a fallback UI.
+ */
+declare class ErrorBoundary extends React__default.Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    constructor(props: ErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
+    componentDidCatch(error: Error, errorInfo: React__default.ErrorInfo): void;
+    componentDidUpdate(prevProps: ErrorBoundaryProps): void;
+    render(): React__default.ReactNode;
+}
+/**
+ * Lightweight boundary specifically for table cells.
+ * Renders inline so it does not break table layout.
+ */
+declare class CellErrorBoundary extends React__default.Component<{
+    onError?: (error: Error, errorInfo: React__default.ErrorInfo) => void;
+    resetKeys?: unknown[];
+    children: React__default.ReactNode;
+}, ErrorBoundaryState> {
+    constructor(props: {
+        onError?: (error: Error, errorInfo: React__default.ErrorInfo) => void;
+        resetKeys?: unknown[];
+        children: React__default.ReactNode;
+    });
+    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
+    componentDidCatch(error: Error, errorInfo: React__default.ErrorInfo): void;
+    componentDidUpdate(prevProps: {
+        resetKeys?: unknown[];
+    }): void;
+    render(): React__default.ReactNode;
+}
+
+interface CellInputProps<TData extends RowData, TValue> {
+    context: CellContext<TData, TValue>;
+    type?: 'text' | 'number' | 'email' | 'url' | 'tel';
+    placeholder?: string;
+    inline?: boolean;
+    autoFocus?: boolean;
+    className?: string;
+}
+declare function CellInput<TData extends RowData, TValue>({ context, type, placeholder, inline, autoFocus, className, }: CellInputProps<TData, TValue>): react_jsx_runtime.JSX.Element;
+
+interface SelectOption {
+    label: string;
+    value: string | number;
+}
+interface CellSelectProps<TData extends RowData, TValue> {
+    context: CellContext<TData, TValue>;
+    options: SelectOption[];
+    placeholder?: string;
+    className?: string;
+}
+declare function CellSelect<TData extends RowData, TValue>({ context, options, placeholder, className, }: CellSelectProps<TData, TValue>): react_jsx_runtime.JSX.Element;
+
+interface CellCheckboxProps<TData extends RowData, TValue> {
+    context: CellContext<TData, TValue>;
+    className?: string;
+}
+declare function CellCheckbox<TData extends RowData, TValue>({ context, className, }: CellCheckboxProps<TData, TValue>): react_jsx_runtime.JSX.Element;
+
+interface CellToggleProps<TData extends RowData, TValue> {
+    context: CellContext<TData, TValue>;
+    className?: string;
+}
+declare function CellToggle<TData extends RowData, TValue>({ context, className, }: CellToggleProps<TData, TValue>): react_jsx_runtime.JSX.Element;
+
+interface CellDatePickerProps<TData extends RowData, TValue> {
+    context: CellContext<TData, TValue>;
+    type?: 'date' | 'datetime-local' | 'time';
+    className?: string;
+}
+declare function CellDatePicker<TData extends RowData, TValue>({ context, type, className, }: CellDatePickerProps<TData, TValue>): react_jsx_runtime.JSX.Element;
+
+declare function CellBadge<TData extends RowData, TValue>({ context, variant, appearance, className, }: CellBadgeProps & {
+    context: CellContext<TData, TValue>;
+}): react_jsx_runtime.JSX.Element | null;
+declare namespace CellBadge {
+    var displayName: string;
+}
+
+declare function CellCurrency<TData extends RowData, TValue>({ context, currency, locale, decimals, colorize, className, }: CellCurrencyProps & {
+    context: CellContext<TData, TValue>;
+}): react_jsx_runtime.JSX.Element | null;
+declare namespace CellCurrency {
+    var displayName: string;
+}
+
+declare function CellStatus<TData extends RowData, TValue>({ context, colorMap, className, }: CellStatusProps & {
+    context: CellContext<TData, TValue>;
+}): react_jsx_runtime.JSX.Element | null;
+declare namespace CellStatus {
+    var displayName: string;
+}
+
+declare function CellNumeric<TData extends RowData, TValue>({ context, locale, unit, decimals, colorize, className, }: CellNumericProps & {
+    context: CellContext<TData, TValue>;
+}): react_jsx_runtime.JSX.Element | null;
+declare namespace CellNumeric {
+    var displayName: string;
+}
+
+declare function CellRating<TData extends RowData, TValue>({ context, max, character, emptyCharacter, className, }: CellRatingProps & {
+    context: CellContext<TData, TValue>;
+}): react_jsx_runtime.JSX.Element | null;
+declare namespace CellRating {
+    var displayName: string;
+}
+
+declare function CellBoolean<TData extends RowData, TValue>({ context, trueLabel, falseLabel, mode, className, }: CellBooleanProps & {
+    context: CellContext<TData, TValue>;
+}): react_jsx_runtime.JSX.Element;
+declare namespace CellBoolean {
+    var displayName: string;
+}
+
+declare function CellProgress<TData extends RowData, TValue>({ context, max, variant, showLabel, className, }: CellProgressProps & {
+    context: CellContext<TData, TValue>;
+}): react_jsx_runtime.JSX.Element | null;
+declare namespace CellProgress {
+    var displayName: string;
+}
+
+declare function CellDate<TData extends RowData, TValue>({ context, format, locale, className, }: CellDateProps & {
+    context: CellContext<TData, TValue>;
+}): react_jsx_runtime.JSX.Element | null;
+declare namespace CellDate {
+    var displayName: string;
+}
+
+declare function CellLink<TData extends RowData, TValue>({ context, href, external, className, }: CellLinkProps & {
+    context: CellContext<TData, TValue>;
+}): react_jsx_runtime.JSX.Element | null;
+declare namespace CellLink {
+    var displayName: string;
+}
+
+interface UseClipboardOptions extends ClipboardOptions {
+    /** Whether clipboard is enabled. Default: true */
+    enabled?: boolean;
+    /** The container element ref to attach listeners to */
+    containerRef?: React.RefObject<HTMLElement | null>;
+    /** Callback when data is copied */
+    onCopy?: (text: string) => void;
+    /** Callback when data is cut */
+    onCut?: (text: string) => void;
+    /** Callback when data is pasted */
+    onPaste?: (text: string) => void;
+}
+/**
+ * React hook that attaches Ctrl+C / Ctrl+X / Ctrl+V keyboard listeners
+ * to the table container for clipboard operations.
+ */
+declare function useClipboard<TData extends RowData>(table: Table$1<TData>, options?: UseClipboardOptions): void;
+
+interface UseKeyboardNavigationOptions {
+    /** Whether keyboard navigation is enabled. Default: true */
+    enabled?: boolean;
+    /** The table container element ref */
+    containerRef?: React.RefObject<HTMLElement | null>;
+}
+declare function useKeyboardNavigation<TData extends RowData>(table: Table$1<TData>, options?: UseKeyboardNavigationOptions): void;
+
+interface FillHandleDragState {
+    isDragging: boolean;
+    sourceCell: {
+        rowIndex: number;
+        columnIndex: number;
+    } | null;
+    currentCell: {
+        rowIndex: number;
+        columnIndex: number;
+    } | null;
+}
+interface UseFillHandleOptions {
+    /** Whether fill handle is enabled. Default: true */
+    enabled?: boolean;
+}
+interface UseFillHandleReturn {
+    dragState: FillHandleDragState;
+    onFillHandleMouseDown: (rowIndex: number, columnIndex: number, e: React.MouseEvent) => void;
+}
+/**
+ * React hook for fill handle drag tracking.
+ * Returns drag state and a mousedown handler to attach to the FillHandle component.
+ */
+declare function useFillHandle<TData extends RowData>(table: Table$1<TData>, options?: UseFillHandleOptions): UseFillHandleReturn;
+
+interface FillHandleProps {
+    /** Row index of the cell this handle belongs to */
+    rowIndex: number;
+    /** Column index of the cell this handle belongs to */
+    columnIndex: number;
+    /** Callback when the user starts dragging the fill handle */
+    onMouseDown: (rowIndex: number, columnIndex: number, e: React__default.MouseEvent) => void;
+}
+/**
+ * Renders a small accent-colored square at the bottom-right corner of a cell.
+ * The user drags this to auto-fill adjacent cells (like Excel/Google Sheets).
+ */
+declare function FillHandle({ rowIndex, columnIndex, onMouseDown, }: FillHandleProps): react_jsx_runtime.JSX.Element;
+
+interface DragHandleProps {
+    /** Called when drag starts on this handle */
+    onDragStart: (e: React__default.DragEvent) => void;
+    /** Whether this handle is currently part of a dragging row */
+    isDragging?: boolean;
+    /** Accessible label */
+    ariaLabel?: string;
+    /** Additional className */
+    className?: string;
+}
+declare function DragHandle({ onDragStart, isDragging, ariaLabel, className, }: DragHandleProps): react_jsx_runtime.JSX.Element;
+
+interface UseRowDragOptions<TData extends RowData> {
+    table: Table$1<TData>;
+    /** Current data array */
+    data: TData[];
+    /** Callback to set data after reorder */
+    onDataChange: (data: TData[]) => void;
+    /** Optional callback when reorder completes */
+    onReorder?: (event: {
+        fromIndex: number;
+        toIndex: number;
+        rowId: string;
+    }) => void;
+}
+interface UseRowDragReturn {
+    /** Current drag state */
+    dragState: RowDragState;
+    /** Props to spread on a draggable row */
+    getRowDragProps: (rowId: string, rowIndex: number) => {
+        draggable: boolean;
+        onDragStart: (e: React.DragEvent) => void;
+        onDragOver: (e: React.DragEvent) => void;
+        onDragLeave: (e: React.DragEvent) => void;
+        onDrop: (e: React.DragEvent) => void;
+        onDragEnd: (e: React.DragEvent) => void;
+        'data-dragging': boolean | undefined;
+        'data-drag-over': string | undefined;
+    };
+    /** Props to spread on a drag handle element */
+    getDragHandleProps: (rowId: string) => {
+        onDragStart: (e: React.DragEvent) => void;
+    };
+}
+declare function useRowDrag<TData extends RowData>({ table, data, onDataChange, onReorder, }: UseRowDragOptions<TData>): UseRowDragReturn;
+
+interface TreeToggleProps<TData extends RowData> {
+    row: Row<TData>;
+    /** Indentation width per level in pixels */
+    indentWidth?: number;
+    /** Whether to show the toggle icon (false for leaf nodes) */
+    showToggle?: boolean;
+    /** Optional custom toggle icon */
+    renderIcon?: (props: {
+        isExpanded: boolean;
+        isLeaf: boolean;
+    }) => React__default.ReactNode;
+}
+declare function TreeToggle<TData extends RowData>({ row, indentWidth, showToggle, renderIcon, }: TreeToggleProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface MasterDetailProps<TData extends RowData> {
+    row: Row<TData>;
+    table: Table$1<TData>;
+    /** Number of columns to span (full table width) */
+    colSpan: number;
+    /** Custom render function for the detail panel */
+    renderDetailPanel?: (row: Row<TData>) => React__default.ReactNode;
+    /** Optional animation class */
+    animationClass?: string;
+}
+declare function MasterDetail<TData extends RowData>({ row, table, colSpan, renderDetailPanel, animationClass, }: MasterDetailProps<TData>): react_jsx_runtime.JSX.Element | null;
+
+interface ExpandIconProps {
+    /** Whether the row is expanded */
+    isExpanded: boolean;
+    /** Click handler to toggle expansion */
+    onClick: (e: React__default.MouseEvent) => void;
+    /** Accessible label */
+    ariaLabel?: string;
+    /** Size of the icon in pixels */
+    size?: number;
+    /** Additional className */
+    className?: string;
+}
+declare function ExpandIcon({ isExpanded, onClick, ariaLabel, size, className, }: ExpandIconProps): react_jsx_runtime.JSX.Element;
+
+interface PivotFieldItem {
+    field: string;
+    label: string;
+}
+interface PivotValueItem {
+    field: string;
+    label: string;
+    aggregation: string;
+}
+interface PivotConfigProps {
+    /** Available fields that can be dragged into zones */
+    availableFields: PivotFieldItem[];
+    /** Currently configured row fields */
+    rowFields: PivotFieldItem[];
+    /** Currently configured column fields */
+    columnFields: PivotFieldItem[];
+    /** Currently configured value fields */
+    valueFields: PivotValueItem[];
+    /** Callback when row fields change */
+    onRowFieldsChange: (fields: PivotFieldItem[]) => void;
+    /** Callback when column fields change */
+    onColumnFieldsChange: (fields: PivotFieldItem[]) => void;
+    /** Callback when value fields change */
+    onValueFieldsChange: (fields: PivotValueItem[]) => void;
+    /** Available aggregation functions */
+    aggregationOptions?: {
+        value: string;
+        label: string;
+    }[];
+    /** Additional className */
+    className?: string;
+}
+declare function PivotConfigPanel({ availableFields, rowFields, columnFields, valueFields, onRowFieldsChange, onColumnFieldsChange, onValueFieldsChange, aggregationOptions, className, }: PivotConfigProps): react_jsx_runtime.JSX.Element;
+
+interface LoadingOverlayProps {
+    /** Whether loading is active */
+    loading?: boolean;
+    /** Custom loading component to render instead of default spinner */
+    loadingComponent?: React__default.ReactNode;
+    /** Loading text shown below the spinner */
+    loadingText?: string;
+}
+declare function LoadingOverlay({ loading, loadingComponent, loadingText, }: LoadingOverlayProps): react_jsx_runtime.JSX.Element | null;
+
+interface NoRowsOverlayProps {
+    /** Custom empty component */
+    emptyComponent?: React__default.ReactNode;
+    /** Custom icon for empty state */
+    emptyIcon?: React__default.ReactNode;
+    /** Main empty message */
+    emptyMessage?: string;
+    /** Secondary detail text */
+    emptyDetail?: string;
+    /** Whether results are filtered (changes icon/message) */
+    isFiltered?: boolean;
+}
+declare function NoRowsOverlay({ emptyComponent, emptyIcon, emptyMessage, emptyDetail, isFiltered, }: NoRowsOverlayProps): react_jsx_runtime.JSX.Element;
+
+interface TooltipPosition {
+    x: number;
+    y: number;
+    placement: 'top' | 'bottom' | 'left' | 'right';
+}
+interface UseTooltipOptions {
+    /** Delay before showing tooltip in ms */
+    delay?: number;
+    /** Preferred placement */
+    placement?: 'top' | 'bottom' | 'left' | 'right';
+    /** Whether tooltip is enabled */
+    enabled?: boolean;
+}
+declare function useTooltip(options?: UseTooltipOptions): {
+    visible: boolean;
+    position: TooltipPosition;
+    content: string;
+    show: (target: HTMLElement, tooltipContent: string) => void;
+    hide: () => void;
+};
+
+interface TooltipProps {
+    /** Whether the tooltip is visible */
+    visible: boolean;
+    /** Position and placement */
+    position: TooltipPosition;
+    /** Tooltip content text */
+    content: string;
+    /** Custom tooltip component */
+    customComponent?: React__default.ReactNode;
+}
+declare function Tooltip({ visible, position, content, customComponent, }: TooltipProps): react_jsx_runtime.JSX.Element | null;
+
+interface CellStatusBadgeBaseProps {
+    onRetry: () => void;
+    onDismiss: () => void;
+}
+interface ErrorProps extends CellStatusBadgeBaseProps {
+    status: 'error';
+    message: string | undefined;
+}
+interface ConflictProps extends CellStatusBadgeBaseProps {
+    status: 'conflict';
+    conflictWith: unknown;
+}
+type CellStatusBadgeProps = ErrorProps | ConflictProps;
+declare function CellStatusBadge(props: CellStatusBadgeProps): react_jsx_runtime.JSX.Element;
+
+interface StatusBarProps<TData extends RowData> {
+    table: Table$1<TData>;
+    panels?: StatusBarPanelConfig[];
+}
+declare function StatusBar<TData extends RowData>({ table, panels, }: StatusBarProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface StatusBarPanelComponentProps {
+    label?: string;
+    value: string | number;
+    icon?: React__default.ReactNode;
+    /** Optional tooltip text */
+    title?: string;
+}
+declare function StatusBarPanelComponent({ label, value, icon, title, }: StatusBarPanelComponentProps): react_jsx_runtime.JSX.Element;
+
+interface FlashCellProps {
+    /** The flash info for this cell (if any) */
+    flash?: CellFlashInfo;
+    /** Flash duration in ms */
+    duration?: number;
+    /** Custom up color */
+    upColor?: string;
+    /** Custom down color */
+    downColor?: string;
+    /** Custom change color */
+    changeColor?: string;
+    /** Cell content */
+    children: React__default.ReactNode;
+}
+declare function FlashCell({ flash, duration, upColor, downColor, changeColor, children, }: FlashCellProps): react_jsx_runtime.JSX.Element;
+
+interface UseCellFlashOptions {
+    /** Flash duration in ms */
+    duration?: number;
+}
+declare function useCellFlash<TData extends RowData>(table: Table$1<TData>, options?: UseCellFlashOptions): {
+    flashes: Map<string, CellFlashInfo>;
+    getFlash: (rowId: string, columnId: string) => CellFlashInfo | undefined;
+};
+
+interface UseRowAnimationOptions {
+    /** Enable row animations. Default: false */
+    enabled?: boolean;
+    /** Transition duration in ms. Default: 250 */
+    duration?: number;
+    /** Easing function. Default: 'ease' */
+    easing?: string;
+}
+declare function useRowAnimation<TData extends RowData>(_table: Table$1<TData>, options?: UseRowAnimationOptions): {
+    capturePositions: (containerEl: HTMLElement | null) => void;
+    animateRows: (containerEl: HTMLElement | null) => void;
+    enabled: boolean;
+};
+
+interface ContextMenuItemDef {
+    id: string;
+    label: string;
+    icon?: React__default.ReactNode;
+    shortcut?: string;
+    disabled?: boolean;
+    danger?: boolean;
+    separator?: boolean;
+    children?: ContextMenuItemDef[];
+    action?: () => void;
+}
+interface ContextMenuItemProps {
+    item: ContextMenuItemDef;
+    onClose: () => void;
+}
+declare function ContextMenuItem({ item, onClose }: ContextMenuItemProps): react_jsx_runtime.JSX.Element;
+
+interface ContextMenuProps<TData extends RowData> {
+    x: number;
+    y: number;
+    onClose: () => void;
+    table: Table$1<TData>;
+    customItems?: ContextMenuItemDef[];
+}
+declare function ContextMenu<TData extends RowData>({ x, y, onClose, table, customItems, }: ContextMenuProps<TData>): react_jsx_runtime.JSX.Element;
+
+declare function useContextMenu(): {
+    isOpen: boolean;
+    x: number;
+    y: number;
+    targetTable: Table$1<any> | null;
+    open: <TData extends RowData>(clientX: number, clientY: number, table: Table$1<TData>) => void;
+    close: () => void;
+};
+
+interface SidebarProps<TData extends RowData> {
+    table: Table$1<TData>;
+    open: boolean;
+    onClose: () => void;
+    panels: ('columns' | 'filters')[];
+    activePanel: 'columns' | 'filters';
+    onPanelChange: (panel: 'columns' | 'filters') => void;
+}
+declare function Sidebar<TData extends RowData>({ table, open, onClose, panels, activePanel, onPanelChange, }: SidebarProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface ColumnsPanelProps<TData extends RowData> {
+    table: Table$1<TData>;
+}
+declare function ColumnsPanel<TData extends RowData>({ table, }: ColumnsPanelProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface FiltersPanelProps<TData extends RowData> {
+    table: Table$1<TData>;
+}
+declare function FiltersPanel<TData extends RowData>({ table, }: FiltersPanelProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface PrintLayoutProps<TData extends RowData> {
+    table: Table$1<TData>;
+    /** Print title displayed at the top */
+    title?: string;
+    /** Show print timestamp */
+    showTimestamp?: boolean;
+}
+declare function PrintLayout<TData extends RowData>({ table, title, showTimestamp, }: PrintLayoutProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface UsePrintLayoutOptions {
+    /** Custom print title */
+    title?: string;
+    /**
+     * Additional CSS to inject for print.
+     *
+     * **Security warning:** Must be developer-provided CSS only.
+     * User-generated CSS is not safe even with sanitization.
+     * The library applies basic sanitization (removing @import, url(), expression())
+     * but this cannot guarantee safety against all CSS-based attacks.
+     */
+    additionalCSS?: string;
+}
+declare function usePrintLayout<TData extends RowData>(table: Table$1<TData>, options?: UsePrintLayoutOptions): {
+    preparePrint: () => void;
+    isPrinting: boolean;
+};
+
+interface UseThemeOptions {
+    /** Initial theme name */
+    defaultTheme?: string;
+    /** Initial color scheme */
+    defaultColorScheme?: 'light' | 'dark' | 'auto';
+}
+declare function useTheme(options?: UseThemeOptions): {
+    theme: string;
+    setTheme: (newTheme: string) => void;
+    colorScheme: "auto" | "light" | "dark";
+    setColorScheme: (scheme: "light" | "dark" | "auto") => void;
+    toggleColorScheme: () => void;
+    resolvedColorScheme: "light" | "dark";
+    containerRef: React$1.RefObject<HTMLElement | null>;
+};
+
+export { type AutoMeasurementsOptions, CellBadge, type CellBadgeProps, CellBoolean, type CellBooleanProps, CellCheckbox, CellCurrency, type CellCurrencyProps, CellDate, CellDatePicker, type CellDateProps, CellErrorBoundary, CellInput, CellLink, type CellLinkProps, type CellMeasureRecipe, type CellMeasurement, CellNumeric, type CellNumericProps, CellProgress, type CellProgressProps, CellRating, type CellRatingProps, CellSelect, CellStatus, CellStatusBadge, type CellStatusBadgeProps, type CellStatusProps, CellToggle, ColumnsPanel, ContextMenu, ContextMenuItem, type ContextMenuItemDef, DEFAULT_TEXT_RECIPE, DragHandle, ErrorBoundary, ExpandIcon, FillHandle, type FillHandleDragState, type FillHandleProps, FiltersPanel, FlashCell, GlobalFilter, LoadingOverlay, type LoadingOverlayProps, MasterDetail, NoRowsOverlay, type NoRowsOverlayProps, Pagination, PivotConfigPanel, type PivotConfigProps, type PivotFieldItem, type PivotValueItem, PrintLayout, Sidebar, SortIndicator, StatusBar, StatusBarPanelComponent, type StatusBarPanelComponentProps, type StatusBarPanelConfig, type StatusBarPanelProps, Table, TableBody, TableCell, type TableCellProps$1 as TableCellProps, TableFooter, TableHeader, type TableHeaderCellProps, type TableProps, TableProvider, type TableRowProps, Tooltip, type TooltipPosition, type TooltipProps, TreeToggle, type UseCellFlashOptions, type UseClipboardOptions, type UseFillHandleOptions, type UseFillHandleReturn, type UseKeyboardNavigationOptions, type UsePretextMeasurementOptions, type UsePretextMeasurementResult, type UsePrintLayoutOptions, type UseRowAnimationOptions, type UseRowDragOptions, type UseRowDragReturn, type UseTableRowHeightsOptions, type UseThemeOptions, type UseTooltipOptions, type UseVirtualizationOptions, type UseVirtualizationResult, type VirtualRow, getMeasureRecipeForCellType, getRegisteredCellTypes, resolveMeasureRecipe, useAutoMeasurements, useCellFlash, useClipboard, useContextMenu, useFillHandle, useKeyboardNavigation, usePretextMeasurement, usePrintLayout, useRowAnimation, useRowDrag, useTable, useTableContext, useTableRowHeights, useTheme, useTooltip, useVirtualization };