@zvndev/yable-react 0.0.0-canary-20260629011348

package/dist/index.d.cts

@@ -0,0 +1,1338 @@
+import { RowData, ColumnDefBase, ColumnDefExtensions, Row, ColumnDef, Table as Table$1, Cell, Header, TableOptions, SortingState, ColumnFiltersState, PaginationState, TableState, Updater, Column, 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, FormulaEngine, FormulaError, FormulaFunction, FormulaState, GroupColumnDef, Header, HeaderContext, HeaderGroup, KeyboardNavigationAction, KeyboardNavigationCell, KeyboardNavigationDirection, KeyboardNavigationState, OnChangeFn, OnCommitFn, PaginationState, PartialLocale, PivotColumn, PivotConfig, PivotEngine, PivotFieldConfig, PivotRow, PivotState, PivotValueConfig, Row, RowData, RowDragEndEvent, RowDragEvent, RowDragState, RowEditCommitEvent, RowEditEvent, RowPinningState, RowReorderEvent, RowSelectionState, SortDirection, SortingFn, SortingState, Table as TableInstance, TableOptions, TableOptionsResolved, TableState, UndoAction, UndoRedoOptions, UndoRedoState, UndoStack, Updater, VisibilityState, YableLocale, aggregationFns, createColumnHelper, createLocale, createUndoRedoIntegration, en, filterFns, formulaFunctions, functionalUpdate, generatePivotColumnDefs, getDefaultLocale, getInitialPivotState, getPivotRowModel, resetLocale, setDefaultLocale, sortingFns } from '@zvndev/yable-core';
+import * as React$1 from 'react';
+import React__default, { CSSProperties, HTMLAttributes, TdHTMLAttributes, ThHTMLAttributes, ReactNode } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { RowDragState } from '@zvndev/yable-core/features/rowDragging';
+
+type YableTableVisualConfig = Partial<Pick<TableProps<any>, 'striped' | 'bordered' | 'compact' | 'stickyHeader' | 'theme' | 'direction' | 'ariaLabel' | 'clickableRows' | 'floatingFilters' | 'columnVirtualization' | 'columnVirtualizationOverscan' | 'statusBar' | 'sidebar' | 'sidebarPanels' | 'defaultSidebarPanel'>>;
+type YableColumnConfig<TData extends RowData = any, TValue = unknown> = Partial<ColumnDefBase<TData, TValue>> & Partial<ColumnDefExtensions<TData, TValue>>;
+interface YableRowConfig<TData extends RowData = any> {
+    className?: string | ((row: Row<TData>) => string | undefined);
+    style?: CSSProperties | ((row: Row<TData>) => CSSProperties);
+}
+type YableCellConfig<TData extends RowData = any, TValue = unknown> = Pick<YableColumnConfig<TData, TValue>, 'cell' | 'cellType' | 'cellTypeProps' | 'cellClassName' | 'cellStyle' | 'editable' | 'editConfig' | 'tooltip' | 'tooltipDelay'>;
+interface YableColumnConfigSet<TData extends RowData = any> {
+    default?: YableColumnConfig<TData>;
+    byId?: Record<string, YableColumnConfig<TData>>;
+}
+interface YableCellConfigSet<TData extends RowData = any> {
+    default?: YableCellConfig<TData>;
+    named?: Record<string, YableCellConfig<TData>>;
+    byColumn?: Record<string, YableCellConfig<TData>>;
+}
+interface YableTableProfile<TData extends RowData = any> {
+    table?: YableTableVisualConfig;
+    columns?: YableColumnConfigSet<TData>;
+    rows?: YableRowConfig<TData>;
+    cells?: YableCellConfigSet<TData>;
+}
+interface YableConfig<TData extends RowData = any> extends YableTableProfile<TData> {
+    profiles?: Record<string, YableTableProfile<TData>>;
+}
+interface ResolvedYableProfile<TData extends RowData = any> extends YableTableProfile<TData> {
+    name: string;
+}
+declare function createYableConfig<TData extends RowData = any>(config: YableConfig<TData>): YableConfig<TData>;
+declare function resolveYableProfile<TData extends RowData = any>(config?: YableConfig<TData>, profileName?: string): ResolvedYableProfile<TData>;
+declare function getYableDefaultColumnDef<TData extends RowData>(profile?: YableTableProfile<TData>): YableColumnConfig<TData> | undefined;
+declare function applyYableConfigToColumns<TData extends RowData>(columns: ColumnDef<TData, any>[], profile?: YableTableProfile<TData>): ColumnDef<TData, any>[];
+
+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;
+    /** Named table profile from `YableProvider config` */
+    configProfile?: string;
+    /** Table-local config; overrides provider config for this component */
+    config?: YableConfig<TData>;
+    /** 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';
+    /** Render a second header row with per-column floating filters */
+    floatingFilters?: boolean;
+    /** Virtualize wide tables horizontally when safe to do so */
+    columnVirtualization?: boolean;
+    /** Additional columns rendered beyond the viewport when column virtualization is enabled */
+    columnVirtualizationOverscan?: number;
+    /** Accessible label for the grid container. Default: "Data table" */
+    ariaLabel?: string;
+}
+/** 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>;
+}
+
+type UseTableOptions<TData extends RowData> = TableOptions<TData> & {
+    /** Table-local config; overrides provider config for this table instance. */
+    config?: YableConfig<TData>;
+    /** Named profile from `YableProvider config`; overrides provider `tableProfile`. */
+    configProfile?: string;
+};
+/**
+ * React hook that wraps the framework-agnostic core table engine.
+ *
+ * Returns a stable {@link Table} instance whose `state` reflects either
+ * the consumer's controlled `options.state` or the hook's internal state.
+ *
+ * Re-renders are triggered by `setState` from the default `onStateChange`
+ * implementation. Consumers may pass their own `onStateChange` to control
+ * state externally.
+ *
+ * Gotcha: `options.onStateChange` is captured via a latest-ref, so a fresh
+ * function identity from the parent is always invoked — even if every other
+ * option key is shallow-equal to the previous render.
+ */
+declare function useTable<TData extends RowData>(options: UseTableOptions<TData>): Table$1<TData>;
+
+interface ServerTableFetchArgs {
+    sorting: SortingState;
+    columnFilters: ColumnFiltersState;
+    globalFilter: string;
+    pagination: PaginationState;
+    cursor: unknown;
+    signal: AbortSignal;
+}
+interface ServerTableFetchResult<TData extends RowData> {
+    rows: TData[];
+    cursor?: unknown;
+    hasMore?: boolean;
+    rowCount?: number;
+    pageCount?: number;
+}
+interface ServerTableUpdateArgs<TData extends RowData> {
+    rowId: string;
+    patch: Partial<TData>;
+    previousRow?: TData;
+    signal: AbortSignal;
+}
+interface UseServerTableOptions<TData extends RowData> extends Omit<UseTableOptions<TData>, 'data' | 'state' | 'manualSorting' | 'manualFiltering' | 'manualPagination' | 'onSortingChange' | 'onColumnFiltersChange' | 'onGlobalFilterChange' | 'onPaginationChange' | 'rowCount' | 'pageCount'> {
+    fetchData: (args: ServerTableFetchArgs) => Promise<ServerTableFetchResult<TData>>;
+    updateRow?: (args: ServerTableUpdateArgs<TData>) => Promise<TData | Partial<TData> | void>;
+    initialRows?: TData[];
+    initialCursor?: unknown;
+    initialHasMore?: boolean;
+    initialRowCount?: number;
+    initialPageCount?: number;
+    initialSorting?: SortingState;
+    initialColumnFilters?: ColumnFiltersState;
+    initialGlobalFilter?: string;
+    initialPagination?: PaginationState;
+    autoLoad?: boolean;
+}
+interface ServerTableController<TData extends RowData> {
+    table: Table$1<TData>;
+    rows: TData[];
+    loading: boolean;
+    error: unknown;
+    cursor: unknown;
+    hasMore: boolean;
+    rowCount?: number;
+    pageCount?: number;
+    sorting: SortingState;
+    columnFilters: ColumnFiltersState;
+    globalFilter: string;
+    pagination: PaginationState;
+    refresh: () => Promise<void>;
+    loadMore: () => Promise<void>;
+    updateRow: (rowId: string, patch: Partial<TData>) => Promise<void>;
+}
+declare function useServerTable<TData extends RowData>({ fetchData, updateRow, initialRows, initialCursor, initialHasMore, initialRowCount, initialPageCount, initialSorting, initialColumnFilters, initialGlobalFilter, initialPagination, autoLoad, getRowId, ...tableOptions }: UseServerTableOptions<TData>): ServerTableController<TData>;
+
+interface UseTablePersistenceOptions {
+    /** Storage key used for getItem/setItem. */
+    key: string;
+    /** Which TableState slices to persist. Defaults to column layout keys. */
+    persistedKeys?: (keyof TableState)[];
+    /** Milliseconds to debounce storage writes. Default: 100. */
+    debounce?: number;
+    /** Schema version — bumping this discards any stale stored data. */
+    version?: number;
+    /** Custom Storage implementation. Default: localStorage. */
+    storage?: Storage;
+}
+interface UseTablePersistenceReturn {
+    /**
+     * Partial state hydrated from storage — pass to `useTable({ initialState })`.
+     * Only useful when NOT passing `onStateChange` (i.e., uncontrolled mode).
+     */
+    initialState: Partial<TableState>;
+    /**
+     * State-change handler that persists relevant slices on each update.
+     * When passed to `useTable({ onStateChange })`, the persistence hook
+     * takes over state management (controlled mode). You MUST also pass
+     * `state` to useTable in this case.
+     */
+    onStateChange: (updater: Updater<TableState>) => void;
+    /**
+     * Current table state managed by the persistence hook.
+     * Pass to `useTable({ state })` alongside `onStateChange`.
+     */
+    state: Partial<TableState>;
+    /** Manually clear all persisted state for this key. */
+    clearPersistedState: () => void;
+}
+/**
+ * React hook that persists selected table state slices to storage.
+ *
+ * Returns `initialState` (hydrated from storage), `state`, and
+ * `onStateChange` — pass all three to `useTable` so that persisted
+ * slices survive page reloads.
+ *
+ * @example
+ * ```tsx
+ * const persistence = useTablePersistence({ key: 'my-table', version: 1 })
+ *
+ * // Controlled mode (recommended) — persistence manages state:
+ * const table = useTable({
+ *   data,
+ *   columns,
+ *   initialState: persistence.initialState,
+ *   state: persistence.state,
+ *   onStateChange: persistence.onStateChange,
+ * })
+ *
+ * // Uncontrolled mode — only hydrate, no live persistence:
+ * const table = useTable({
+ *   data,
+ *   columns,
+ *   initialState: persistence.initialState,
+ * })
+ * ```
+ */
+declare function useTablePersistence(options: UseTablePersistenceOptions): UseTablePersistenceReturn;
+
+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;
+    /**
+     * Opaque key that changes when column widths change.
+     * When this value changes the height cache is invalidated because column
+     * resizing can affect text wrapping and therefore row heights.
+     */
+    columnSizingHash?: string | number;
+}
+interface UseVirtualizationResult {
+    virtualRows: VirtualRow[];
+    totalHeight: number;
+    startIndex: number;
+    endIndex: number;
+    scrollTo: (index: number) => void;
+    /**
+     * Manually clear the row-height cache and force recalculation.
+     * Call this when cell content changes (data mutations, font-size changes, etc.)
+     * that may affect row heights.
+     */
+    invalidateRowHeights: () => void;
+}
+/**
+ * Computes which rows are visible in a scrollable container and returns
+ * positioning data so only those rows (plus an overscan buffer) are rendered.
+ *
+ * Returns `{ virtualRows, totalHeight, startIndex, endIndex, scrollTo, invalidateRowHeights }`.
+ * Re-renders are triggered by scroll (rAF-throttled) and ResizeObserver
+ * container resize. Supports fixed, variable, and Pretext-pre-measured heights.
+ *
+ * The height cache is automatically invalidated when `totalRows`, `isFixedHeight`,
+ * or `columnSizingHash` changes. For manual invalidation (e.g. after data mutations
+ * or font-size changes), call `invalidateRowHeights()`.
+ */
+declare function useVirtualization({ containerRef, totalRows, rowHeight, overscan, estimateRowHeight: _estimateRowHeight, pretextHeights, pretextPrefixSums, columnSizingHash, }: UseVirtualizationOptions): UseVirtualizationResult;
+
+interface VirtualColumn<TData extends RowData> {
+    column: Column<TData, unknown>;
+    index: number;
+    start: number;
+    size: number;
+}
+interface UseColumnVirtualizationOptions<TData extends RowData> {
+    containerRef: React.RefObject<HTMLElement | null>;
+    columns: Column<TData, unknown>[];
+    overscan?: number;
+    enabled?: boolean;
+    sizingKey?: string;
+}
+interface UseColumnVirtualizationResult<TData extends RowData> {
+    virtualColumns: VirtualColumn<TData>[];
+    startOffset: number;
+    endOffset: number;
+    totalWidth: number;
+    visibleWidth: number;
+    startIndex: number;
+    endIndex: number;
+    isVirtualized: boolean;
+    scrollToIndex: (index: number) => void;
+}
+declare function useColumnVirtualization<TData extends RowData>({ containerRef, columns, overscan, enabled, sizingKey, }: UseColumnVirtualizationOptions<TData>): UseColumnVirtualizationResult<TData>;
+
+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 `{ rowHeights, prefixSums, totalHeight, ready, ... }` as typed
+ * arrays for cache-friendly access by the virtualizer. `prepare()` re-runs
+ * when `data` or fonts change; `layout()` re-runs only when column widths
+ * change (pure math, ~0.0003ms per cell).
+ *
+ * Gotcha: pretext is loaded lazily — `ready` flips to true on the first
+ * render after the dynamic import resolves and heights are computed.
+ */
+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>;
+
+/**
+ * Project-wide default table and column options.
+ *
+ * Wrap your app (or a subtree) in `<YableProvider>` so every `<Table>` and
+ * `useTable` call inherits these defaults without repeating config.
+ *
+ * Component-level and hook-level values always take precedence over provider
+ * defaults.
+ */
+interface YableDefaults {
+    /** Layered project config with default and named table/cell profiles */
+    config?: YableConfig;
+    /** Named config profile used by descendants unless overridden */
+    tableProfile?: string;
+    /** Default props applied to every `<Table>` in the subtree */
+    tableProps?: Partial<Pick<TableProps<any>, 'striped' | 'bordered' | 'compact' | 'stickyHeader' | 'theme' | 'direction' | 'ariaLabel'>>;
+    /** Default column definition merged under every table's own `defaultColumnDef` */
+    defaultColumnDef?: Partial<ColumnDefBase<any, unknown>> & Partial<ColumnDefExtensions<any, unknown>>;
+}
+/**
+ * Read the nearest `YableProvider` defaults.
+ *
+ * Safe to call outside a provider — returns an empty object.
+ */
+declare function useYableDefaults(): YableDefaults;
+/**
+ * Provide project-wide defaults for all Yable tables in a subtree.
+ *
+ * @example
+ * ```tsx
+ * <YableProvider
+ *   striped
+ *   stickyHeader
+ *   theme="stripe"
+ *   defaultColumnDef={{ enableSorting: true }}
+ * >
+ *   <EmployeeTable />
+ *   <ProjectTable />
+ * </YableProvider>
+ * ```
+ */
+declare function YableProvider({ children, config, tableProfile, defaultColumnDef, striped, stickyHeader, bordered, compact, theme, direction, ariaLabel, }: YableDefaults & {
+    children: ReactNode;
+    striped?: boolean;
+    stickyHeader?: boolean;
+    bordered?: boolean;
+    compact?: boolean;
+    theme?: string;
+    direction?: 'ltr' | 'rtl';
+    ariaLabel?: string;
+}): react_jsx_runtime.JSX.Element;
+
+declare function Table<TData extends RowData>({ table, stickyHeader: stickyHeaderProp, striped: stripedProp, bordered: borderedProp, compact: compactProp, theme: themeProp, config, configProfile, clickableRows, footer, loading, loadingComponent, loadingText, emptyMessage, emptyComponent, emptyIcon, emptyDetail, renderEmpty, renderLoading, children, className, direction: directionProp, statusBar, statusBarPanels, sidebar, sidebarPanels, defaultSidebarPanel, floatingFilters, columnVirtualization, columnVirtualizationOverscan, ariaLabel: ariaLabelProp, ...rest }: TableProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface TableHeaderProps<TData extends RowData> {
+    table: Table$1<TData>;
+    floatingFilters?: boolean;
+}
+declare function TableHeader<TData extends RowData>({ table, floatingFilters, }: TableHeaderProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface TableBodyProps<TData extends RowData> {
+    table: Table$1<TData>;
+    clickableRows?: boolean;
+    colgroup?: React__default.ReactNode;
+    /** Stable mousedown handler for the fill handle, lifted from `useFillHandle`. */
+    onFillHandleMouseDown?: (rowIndex: number, columnIndex: number, e: React__default.MouseEvent) => void;
+}
+declare function TableBody<TData extends RowData>({ table, clickableRows, colgroup, onFillHandleMouseDown, }: 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;
+    /** Mousedown handler for the fill handle; when present and the table has
+     * `enableFillHandle`, the focused cell renders a drag-to-fill corner. */
+    onFillHandleMouseDown?: (rowIndex: number, columnIndex: number, e: React__default.MouseEvent) => void;
+}
+declare function TableCell<TData extends RowData>({ cell, table, rowIndex, columnIndex, isFocused, isTabStop, onFillHandleMouseDown, }: 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 FloatingFilterProps<TData extends RowData> {
+    column: Column<TData, unknown>;
+}
+declare function FloatingFilter<TData extends RowData>({ column }: FloatingFilterProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface SetFilterProps<TData extends RowData> {
+    column: Column<TData, unknown>;
+    className?: string;
+}
+declare function SetFilter<TData extends RowData>({ column, className }: SetFilterProps<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>;
+    /** Column the menu was opened on (right-clicked header/cell). */
+    targetColumnId?: string;
+    customItems?: ContextMenuItemDef[];
+}
+declare function ContextMenu<TData extends RowData>({ x, y, onClose, table, targetColumnId, customItems, }: ContextMenuProps<TData>): react_jsx_runtime.JSX.Element;
+
+declare function useContextMenu(): {
+    isOpen: boolean;
+    x: number;
+    y: number;
+    targetTable: Table$1<any> | null;
+    targetColumnId: string | undefined;
+    open: <TData extends RowData>(clientX: number, clientY: number, table: Table$1<TData>, columnId?: string) => 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" | "dark" | "light";
+    setColorScheme: (scheme: "light" | "dark" | "auto") => void;
+    toggleColorScheme: () => void;
+    resolvedColorScheme: "dark" | "light";
+    containerRef: React$1.RefObject<HTMLElement | null>;
+};
+
+interface SelectColumnOptions {
+    id?: string;
+    size?: number;
+    headerAriaLabel?: string;
+}
+declare function selectColumn<TData extends RowData>(options?: SelectColumnOptions): ColumnDef<TData, unknown>;
+
+interface RowNumberColumnOptions {
+    id?: string;
+    header?: string;
+    size?: number;
+    startFrom?: number;
+}
+declare function rowNumberColumn<TData extends RowData>(options?: RowNumberColumnOptions): ColumnDef<TData, unknown>;
+
+interface ActionItem<TData extends RowData> {
+    label: string;
+    icon?: ReactNode;
+    onClick: (row: Row<TData>) => void;
+    hidden?: (row: Row<TData>) => boolean;
+    disabled?: (row: Row<TData>) => boolean;
+}
+interface ActionsColumnOptions<TData extends RowData> {
+    id?: string;
+    header?: string;
+    size?: number;
+    actions: ActionItem<TData>[] | ((row: Row<TData>) => ActionItem<TData>[]);
+}
+declare function actionsColumn<TData extends RowData>(options: ActionsColumnOptions<TData>): ColumnDef<TData, unknown>;
+
+interface ExpandColumnOptions {
+    id?: string;
+    size?: number;
+}
+declare function expandColumn<TData extends RowData>(options?: ExpandColumnOptions): ColumnDef<TData, unknown>;
+
+interface CellStackProps {
+    children: React__default.ReactNode;
+    gap?: number;
+}
+declare function CellStack({ children, gap }: CellStackProps): react_jsx_runtime.JSX.Element;
+
+interface CellRowProps {
+    children: React__default.ReactNode;
+    gap?: number;
+    align?: 'start' | 'center' | 'end' | 'baseline';
+    justify?: 'start' | 'center' | 'end' | 'between';
+}
+declare function CellRow({ children, gap, align, justify }: CellRowProps): react_jsx_runtime.JSX.Element;
+
+interface CellWithIconProps {
+    icon: React__default.ReactNode;
+    children: React__default.ReactNode;
+    gap?: number;
+    iconSize?: number;
+}
+declare function CellWithIcon({ icon, children, gap, iconSize }: CellWithIconProps): react_jsx_runtime.JSX.Element;
+
+interface CellTextProps {
+    children: React__default.ReactNode;
+    variant?: 'primary' | 'secondary' | 'muted';
+    bold?: boolean;
+    truncate?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+}
+declare function CellText({ children, variant, bold, truncate, size, }: CellTextProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Merges edit-commit changes into a data array, returning a new array
+ * with matching rows shallow-merged. Rows without changes keep their
+ * original reference so downstream memoisation works.
+ *
+ * @param data     Current data array
+ * @param changes  Map of row ID -> partial row values (same shape as `onEditCommit`)
+ * @param getRowId Optional row-ID resolver; defaults to string index
+ */
+declare function mergeEditChanges<TData>(data: TData[], changes: Record<string, Partial<TData>>, getRowId?: (row: TData, index: number) => string): TData[];
+
+export { type ActionItem, type ActionsColumnOptions, 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, CellRow, type CellRowProps, CellSelect, CellStack, type CellStackProps, CellStatus, CellStatusBadge, type CellStatusBadgeProps, type CellStatusProps, CellText, type CellTextProps, CellToggle, CellWithIcon, type CellWithIconProps, ColumnsPanel, ContextMenu, ContextMenuItem, type ContextMenuItemDef, DEFAULT_TEXT_RECIPE, DragHandle, ErrorBoundary, type ExpandColumnOptions, ExpandIcon, FillHandle, type FillHandleDragState, type FillHandleProps, FiltersPanel, FlashCell, FloatingFilter, GlobalFilter, LoadingOverlay, type LoadingOverlayProps, MasterDetail, NoRowsOverlay, type NoRowsOverlayProps, Pagination, PivotConfigPanel, type PivotConfigProps, type PivotFieldItem, type PivotValueItem, PrintLayout, type ResolvedYableProfile, type RowNumberColumnOptions, type SelectColumnOptions, type ServerTableController, type ServerTableFetchArgs, type ServerTableFetchResult, type ServerTableUpdateArgs, SetFilter, 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 UseColumnVirtualizationOptions, type UseColumnVirtualizationResult, type UseFillHandleOptions, type UseFillHandleReturn, type UseKeyboardNavigationOptions, type UsePretextMeasurementOptions, type UsePretextMeasurementResult, type UsePrintLayoutOptions, type UseRowAnimationOptions, type UseRowDragOptions, type UseRowDragReturn, type UseServerTableOptions, type UseTableOptions, type UseTablePersistenceOptions, type UseTablePersistenceReturn, type UseTableRowHeightsOptions, type UseThemeOptions, type UseTooltipOptions, type UseVirtualizationOptions, type UseVirtualizationResult, type VirtualColumn, type VirtualRow, type YableCellConfig, type YableCellConfigSet, type YableColumnConfig, type YableColumnConfigSet, type YableConfig, type YableDefaults, YableProvider, type YableRowConfig, type YableTableProfile, type YableTableVisualConfig, actionsColumn, applyYableConfigToColumns, createYableConfig, expandColumn, getMeasureRecipeForCellType, getRegisteredCellTypes, getYableDefaultColumnDef, mergeEditChanges, resolveMeasureRecipe, resolveYableProfile, rowNumberColumn, selectColumn, useAutoMeasurements, useCellFlash, useClipboard, useColumnVirtualization, useContextMenu, useFillHandle, useKeyboardNavigation, usePretextMeasurement, usePrintLayout, useRowAnimation, useRowDrag, useServerTable, useTable, useTableContext, useTablePersistence, useTableRowHeights, useTheme, useTooltip, useVirtualization, useYableDefaults };