@pretable/react 0.0.1 → 0.0.2

package/dist/index.d.ts

@@ -1,15 +1,44 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { PretableRow, PretableColumn, PretableGridOptions, PretableGrid, PretableGridSnapshot, AutosizeOptions, PretableSortDirection } from '@pretable/core';
-export { PretableColumn, PretableGrid, PretableGridOptions, PretableGridSnapshot, PretableRow } from '@pretable/core';
-import { HTMLAttributes, ReactNode, CSSProperties } from 'react';
+import { PretableRow, PretableColumn as PretableColumn$1, PretableFormatInput, PretableFocusState, PretableSelectionState, PretableSortState, PretableGrid, PretableGridSnapshot, AutosizeOptions, PretableGridOptions, PretableCellRange, PretableVisibleRow, PretableSortDirection } from '@pretable/core';
+export { PretableFormatInput, PretableGrid, PretableGridOptions, PretableGridSnapshot, PretableRow } from '@pretable/core';
+import { ReactNode, HTMLAttributes, CSSProperties } from 'react';
+import { DensityHeights } from '@pretable/ui';
+export { DensityHeights } from '@pretable/ui';
 
-interface PretableProps<TRow extends PretableRow = PretableRow> {
-    columns: PretableColumn<TRow>[];
-    getRowId?: PretableGridOptions<TRow>["getRowId"];
-    rows: TRow[];
+/**
+ * React-extended column definition. Adds the `render` and `renderHeader` JSX-typed callbacks on top of `@pretable/core`'s base column.
+ *
+ * @public
+ */
+interface PretableColumn<TRow extends PretableRow = PretableRow> extends PretableColumn$1<TRow> {
+    render?: (input: PretableCellRenderInput<TRow>) => ReactNode;
+    renderHeader?: (input: PretableHeaderRenderInput<TRow>) => ReactNode;
+}
+/**
+ * Input passed to a column's `render` function.
+ *
+ * @public
+ */
+interface PretableCellRenderInput<TRow extends PretableRow = PretableRow> extends PretableFormatInput<TRow> {
+    formattedValue: string;
+    rowId: string;
+    rowIndex: number;
+    isFocused: boolean;
+    isSelected: boolean;
+}
+/**
+ * Input passed to a column's `renderHeader` function.
+ *
+ * @public
+ */
+interface PretableHeaderRenderInput<TRow extends PretableRow = PretableRow> {
+    column: PretableColumn<TRow>;
+    label: string;
+    sortDirection: "asc" | "desc" | null;
+    isSorted: boolean;
 }
-declare function Pretable<TRow extends PretableRow = PretableRow>({ columns, getRowId, rows, }: PretableProps<TRow>): react_jsx_runtime.JSX.Element;
 
+/** @internal */
 interface PlannedColumn {
     index: number;
     id: string;
@@ -18,12 +47,11 @@ interface PlannedColumn {
     pinned?: "left";
 }
 
-interface UsePretableOptions<TRow extends PretableRow = PretableRow> {
-    autosize?: boolean | AutosizeOptions;
-    columns: PretableColumn<TRow>[];
-    rows: TRow[];
-    getRowId?: PretableGridOptions<TRow>["getRowId"];
-}
+/**
+ * One row of layout-derived render state for use during custom rendering.
+ *
+ * @public
+ */
 interface PretableRenderRow<TRow extends PretableRow = PretableRow> {
     id: string;
     row: TRow;
@@ -31,6 +59,13 @@ interface PretableRenderRow<TRow extends PretableRow = PretableRow> {
     top: number;
     height: number;
 }
+/**
+ * Layout-derived render snapshot returned by {@link usePretable}. Drives
+ * positioned-cell rendering — every column has a left + width, every visible
+ * row has a top + height.
+ *
+ * @public
+ */
 interface PretableRenderSnapshot<TRow extends PretableRow = PretableRow> {
     columns: PlannedColumn[];
     rows: PretableRenderRow<TRow>[];
@@ -38,6 +73,12 @@ interface PretableRenderSnapshot<TRow extends PretableRow = PretableRow> {
     totalHeight: number;
     totalWidth: number;
 }
+/**
+ * Telemetry numbers about the current render — counts and ranges suitable
+ * for status bars, dev panels, or virtualization debugging.
+ *
+ * @public
+ */
 interface PretableTelemetry {
     focusedRowId: string | null;
     rowModelRowCount: number;
@@ -51,45 +92,146 @@ interface PretableTelemetry {
         start: number;
     };
 }
-interface PretableInteractionOverrides {
+/**
+ * **Input** shape for controlling a {@link PretableSurface} from the outside.
+ * Pass the slices you want to control; omit slices you want the grid to own.
+ *
+ * @public
+ */
+interface PretableSurfaceState {
     filters?: Record<string, string>;
-    focusedRowId?: string | null;
-    selectedRowId?: string | null;
-    sort?: {
-        columnId: string;
-        direction: PretableSortDirection;
-    } | null;
+    focus?: PretableFocusState;
+    selection?: PretableSelectionState;
+    sort?: PretableSortState | null;
+    columnWidths?: Record<string, number>;
+    columnOrder?: readonly string[];
+    columnPinned?: Record<string, "left" | null>;
 }
-interface UsePretableModelOptions<TRow extends PretableRow = PretableRow> extends UsePretableOptions<TRow> {
+/**
+ * Options for the {@link usePretable} hook.
+ *
+ * @public
+ */
+interface UsePretableOptions<TRow extends PretableRow = PretableRow> {
+    autosize?: boolean | AutosizeOptions;
+    columns: PretableColumn<TRow>[];
+    rows: TRow[];
+    getRowId?: PretableGridOptions<TRow>["getRowId"];
     viewportHeight: number;
     viewportWidth?: number;
     overscan?: number;
-    interactionOverrides?: PretableInteractionOverrides | null;
+    state?: PretableSurfaceState | null;
     measuredHeights?: Record<string, number>;
+    onSelectionChange?: (next: PretableSelectionState) => void;
+    onFocusChange?: (next: PretableFocusState) => void;
 }
+/**
+ * Output of the {@link usePretable} hook — a stable handle plus the latest
+ * snapshot, render layout, and telemetry.
+ *
+ * @public
+ */
 interface PretableModel<TRow extends PretableRow = PretableRow> {
     grid: PretableGrid<TRow>;
     snapshot: PretableGridSnapshot<TRow>;
     renderSnapshot: PretableRenderSnapshot<TRow>;
     telemetry: PretableTelemetry;
 }
-declare function usePretable<TRow extends PretableRow = PretableRow>({ autosize, columns, rows, getRowId, }: UsePretableOptions<TRow>): PretableGrid<TRow>;
-declare function usePretableModel<TRow extends PretableRow = PretableRow>({ autosize, columns, rows, getRowId, viewportHeight, viewportWidth, overscan, interactionOverrides, measuredHeights, }: UsePretableModelOptions<TRow>): PretableModel<TRow>;
+/**
+ * The primary React hook. Creates a grid, applies optional controlled state,
+ * and returns the latest snapshot, layout-derived render snapshot, and
+ * telemetry. Suitable for custom rendering — `<PretableSurface>` itself is
+ * built on top of this hook.
+ *
+ * @example
+ * ```tsx
+ * const { grid, snapshot, renderSnapshot, telemetry } = usePretable({
+ *   columns,
+ *   rows,
+ *   viewportHeight: 480,
+ * });
+ * ```
+ *
+ * @public
+ */
+declare function usePretable<TRow extends PretableRow = PretableRow>({ autosize, columns, rows, getRowId, viewportHeight, viewportWidth, overscan, state, measuredHeights, onSelectionChange, onFocusChange, }: UsePretableOptions<TRow>): PretableModel<TRow>;
+
+/**
+ * Reserved column id for the synthetic row-select checkbox column.
+ * Internal — surface authors shouldn't reference this directly.
+ *
+ * @internal
+ */
+declare const ROW_SELECT_COLUMN_ID = "__pretable_row_select__";
 
+/**
+ * Input for {@link serializeRangesAsTsv}.
+ *
+ * @public
+ */
+interface SerializeRangesArgs<TRow extends PretableRow> {
+    ranges: readonly PretableCellRange[];
+    visibleRows: readonly PretableVisibleRow<TRow>[];
+    columns: readonly PretableColumn<TRow>[];
+    copyWithHeaders?: boolean;
+}
+/**
+ * Plain-text + HTML pair returned by clipboard serializers and consumed by `onCopy` / `copyToClipboard` props.
+ *
+ * @public
+ */
+interface CopyPayload {
+    text: string;
+    html?: string;
+}
+/**
+ * Default coerce-value-to-string used during clipboard serialization. Useful as a fallback inside custom serializers.
+ *
+ * @public
+ */
+declare function defaultCoerceForCopy(value: unknown): string;
+/**
+ * Serialize one or more `PretableCellRange`s to a tab-separated text + HTML payload suitable for clipboard write.
+ *
+ * @public
+ */
+declare function serializeRangesAsTsv<TRow extends PretableRow>(args: SerializeRangesArgs<TRow>): CopyPayload | null;
+
+/**
+ * Configuration for the synthetic row-select column rendered by {@link PretableSurface} when `rowSelectionColumn` is enabled.
+ *
+ * @public
+ */
+interface RowSelectionColumnConfig {
+    enabled: true;
+    position?: "left";
+    pinned?: boolean;
+    headerCheckbox?: boolean;
+    width?: number;
+}
+/**
+ * Localizable user-facing strings rendered by {@link PretableSurface}. Pass to override the English defaults.
+ *
+ * @public
+ */
+interface PretableSurfaceMessages {
+    selectAllAnnouncement?: (args: {
+        rowCount: number;
+        columnCount: number;
+        isAll: boolean;
+    }) => string;
+    copyAnnouncement?: (args: {
+        rowCount: number;
+        columnCount: number;
+    }) => string;
+    copyFailedAnnouncement?: () => string;
+}
 interface PretableSurfaceHeaderCellRenderInput<TRow extends PretableRow = PretableRow> {
     column: PretableColumn<TRow>;
     label: string;
     sortDirection: "asc" | "desc" | null;
 }
-interface PretableSurfaceBodyCellRenderInput<TRow extends PretableRow = PretableRow> {
-    column: PretableColumn<TRow>;
-    isFocused: boolean;
-    isSelected: boolean;
-    row: TRow;
-    rowId: string;
-    rowIndex: number;
-    value: unknown;
-}
+type PretableSurfaceBodyCellRenderInput<TRow extends PretableRow = PretableRow> = PretableCellRenderInput<TRow>;
 interface PretableSurfaceRowClassNameInput<TRow extends PretableRow = PretableRow> {
     isFocused: boolean;
     isSelected: boolean;
@@ -111,15 +253,11 @@ interface PretableSurfaceRowAttributesInput<TRow extends PretableRow = PretableR
     rowId: string;
     rowIndex: number;
 }
-interface PretableSurfaceInteractionState {
-    filters?: Record<string, string>;
-    focusedRowId?: string | null;
-    selectedRowId?: string | null;
-    sort?: {
-        columnId: string;
-        direction: "asc" | "desc";
-    } | null;
-}
+/**
+ * Props for {@link PretableSurface}.
+ *
+ * @public
+ */
 interface PretableSurfaceProps<TRow extends PretableRow = PretableRow> {
     ariaLabel: string;
     autosize?: boolean | AutosizeOptions;
@@ -138,24 +276,94 @@ interface PretableSurfaceProps<TRow extends PretableRow = PretableRow> {
      * by the bench harness for plan replay; exposed for advanced consumers
      * who need to drive the grid from external state. Shape may change
      * across minor releases.
+     *
+     * Each slice ({@link PretableSurfaceState.sort}, `filters`, `selection`,
+     * `focus`) follows the same controlled/uncontrolled pattern: when a slice
+     * is provided (non-undefined) the engine state is forced to it on every
+     * render; when a slice is undefined the engine owns it (uncontrolled).
      */
-    interactionState?: PretableSurfaceInteractionState | null;
+    state?: PretableSurfaceState | null;
     overscan?: number;
     onSelectedRowIdChange?: (rowId: string | null) => void;
+    onSelectionChange?: (next: PretableSelectionState) => void;
+    onFocusChange?: (next: PretableFocusState) => void;
     onSortChange?: (sort: {
         columnId: string;
         direction: "asc" | "desc";
     } | null) => void;
+    onColumnWidthsChange?: (next: Record<string, number>) => void;
+    onColumnOrderChange?: (next: readonly string[]) => void;
+    onColumnPinnedChange?: (next: Record<string, "left" | null>) => void;
     onTelemetryChange?: (telemetry: PretableTelemetry) => void;
     onGridReady?: (grid: PretableGrid<TRow>) => void;
     renderBodyCell?: (input: PretableSurfaceBodyCellRenderInput<TRow>) => ReactNode;
     renderHeaderCell?: (input: PretableSurfaceHeaderCellRenderInput<TRow>) => ReactNode;
     rows: TRow[];
+    rowSelectionColumn?: RowSelectionColumnConfig;
     selectFocusedRowOnArrowKey?: boolean;
+    /**
+     * Tab key behavior. Default `"wrap-rows"` matches Grid Alpha / Sheets — Tab
+     * moves focus right and wraps to the next row's first cell at row end;
+     * Shift+Tab wraps backward. `"exit"` lets the browser handle Tab so focus
+     * leaves the grid (strict ARIA grid pattern).
+     */
+    tabBehavior?: "wrap-rows" | "exit";
     viewportStyle?: CSSProperties;
     viewportHeight: number;
+    /**
+     * When true, Cmd/Ctrl+C copy emits a header row (followed by a blank line)
+     * before the selected rows in each range block. Defaults to `false`.
+     */
+    copyWithHeaders?: boolean;
+    /**
+     * Override the TSV serialization step. Receives the args that would be
+     * passed to {@link serializeRangesAsTsv}; returning `null` cancels the copy.
+     */
+    onCopy?: (args: SerializeRangesArgs<TRow>) => CopyPayload | null;
+    /**
+     * Override the clipboard write step. Defaults to writing
+     * `payload.text` (and `payload.html` if present) via `navigator.clipboard`.
+     */
+    copyToClipboard?: (payload: CopyPayload) => void | Promise<void>;
+    /**
+     * Localized message factories for ARIA live announcements (select-all,
+     * copy success, copy failure). Each entry is optional; missing entries
+     * fall back to English defaults.
+     */
+    messages?: PretableSurfaceMessages;
 }
-declare function PretableSurface<TRow extends PretableRow = PretableRow>({ ariaLabel, autosize, columns, getBodyCellClassName, getBodyCellProps, getHeaderCellClassName, getHeaderCellProps, getRowClassName, getRowId, getRowProps, interactionState, overscan, onGridReady, onSelectedRowIdChange, onSortChange, onTelemetryChange, renderBodyCell, renderHeaderCell, rows, selectFocusedRowOnArrowKey, viewportStyle, viewportHeight, }: PretableSurfaceProps<TRow>): react_jsx_runtime.JSX.Element;
+/**
+ * Controlled grid surface. The primary React component. Pass `state` to control any subset of sort/filter/selection/focus/column-layout from the outside; omit slices you want the grid to own.
+ *
+ * @public
+ */
+declare function PretableSurface<TRow extends PretableRow = PretableRow>({ ariaLabel, autosize, columns, getBodyCellClassName, getBodyCellProps, getHeaderCellClassName, getHeaderCellProps, getRowClassName, getRowId, getRowProps, state, overscan, onGridReady, onSelectedRowIdChange, onSelectionChange, onFocusChange, onSortChange, onColumnWidthsChange, onColumnOrderChange, onColumnPinnedChange, onTelemetryChange, renderBodyCell, renderHeaderCell, rows, rowSelectionColumn, selectFocusedRowOnArrowKey, tabBehavior, viewportStyle, viewportHeight, copyWithHeaders, onCopy, copyToClipboard, messages, }: PretableSurfaceProps<TRow>): react_jsx_runtime.JSX.Element;
+
+/**
+ * Props for the {@link Pretable} drop-in component.
+ *
+ * @public
+ */
+interface PretableProps<TRow extends PretableRow = PretableRow> {
+    columns: PretableColumn<TRow>[];
+    getRowId?: PretableGridOptions<TRow>["getRowId"];
+    rows: TRow[];
+    rowSelectionColumn?: PretableSurfaceProps<TRow>["rowSelectionColumn"];
+    tabBehavior?: PretableSurfaceProps<TRow>["tabBehavior"];
+    copyWithHeaders?: PretableSurfaceProps<TRow>["copyWithHeaders"];
+    onCopy?: PretableSurfaceProps<TRow>["onCopy"];
+    copyToClipboard?: PretableSurfaceProps<TRow>["copyToClipboard"];
+    messages?: PretableSurfaceProps<TRow>["messages"];
+    onColumnWidthsChange?: PretableSurfaceProps<TRow>["onColumnWidthsChange"];
+    onColumnOrderChange?: PretableSurfaceProps<TRow>["onColumnOrderChange"];
+    onColumnPinnedChange?: PretableSurfaceProps<TRow>["onColumnPinnedChange"];
+}
+/**
+ * Drop-in pretable component. Wraps {@link PretableSurface} with internal state — pass `columns` and `rows` and you're done. Reach for `PretableSurface` when you need to control state from the outside.
+ *
+ * @public
+ */
+declare function Pretable<TRow extends PretableRow = PretableRow>({ columns, getRowId, rows, rowSelectionColumn, tabBehavior, copyWithHeaders, onCopy, copyToClipboard, messages, onColumnWidthsChange, onColumnOrderChange, onColumnPinnedChange, }: PretableProps<TRow>): react_jsx_runtime.JSX.Element;
 
 type InspectionSeverity = "trace" | "info" | "warn" | "error";
 interface InspectionRow extends Record<string, unknown> {
@@ -169,24 +377,55 @@ interface InspectionRow extends Record<string, unknown> {
 }
 type InspectionFilterableColumnId = "timestamp" | "severity" | "source" | "message";
 
+/**
+ * Props for {@link InspectionGrid}.
+ *
+ * @beta
+ */
 interface InspectionGridProps {
     ariaLabel: string;
     filterableColumnIds: readonly InspectionFilterableColumnId[];
-    interactionState?: PretableSurfaceProps<InspectionRow>["interactionState"];
+    state?: PretableSurfaceProps<InspectionRow>["state"];
     onSelectedRowIdChange?: (rowId: string | null) => void;
+    onSelectionChange?: PretableSurfaceProps<InspectionRow>["onSelectionChange"];
+    onFocusChange?: PretableSurfaceProps<InspectionRow>["onFocusChange"];
     onSortChange?: PretableSurfaceProps<InspectionRow>["onSortChange"];
+    onColumnWidthsChange?: PretableSurfaceProps<InspectionRow>["onColumnWidthsChange"];
+    onColumnOrderChange?: PretableSurfaceProps<InspectionRow>["onColumnOrderChange"];
+    onColumnPinnedChange?: PretableSurfaceProps<InspectionRow>["onColumnPinnedChange"];
     onTelemetryChange?: (telemetry: PretableTelemetry) => void;
     overscan?: number;
     rows: InspectionRow[];
+    rowSelectionColumn?: PretableSurfaceProps<InspectionRow>["rowSelectionColumn"];
+    tabBehavior?: PretableSurfaceProps<InspectionRow>["tabBehavior"];
+    copyWithHeaders?: PretableSurfaceProps<InspectionRow>["copyWithHeaders"];
+    onCopy?: PretableSurfaceProps<InspectionRow>["onCopy"];
+    copyToClipboard?: PretableSurfaceProps<InspectionRow>["copyToClipboard"];
+    messages?: PretableSurfaceProps<InspectionRow>["messages"];
     viewportHeight: number;
 }
-declare function InspectionGrid({ ariaLabel, filterableColumnIds, interactionState, onSelectedRowIdChange, onSortChange, onTelemetryChange, overscan, rows, viewportHeight, }: InspectionGridProps): react_jsx_runtime.JSX.Element;
+/**
+ * Special-purpose inspection surface that renders rows as labeled key/value pairs. Experimental — shape may change before 1.0.
+ *
+ * @beta
+ */
+declare function InspectionGrid({ ariaLabel, filterableColumnIds, state, onSelectedRowIdChange, onSelectionChange, onFocusChange, onSortChange, onColumnWidthsChange, onColumnOrderChange, onColumnPinnedChange, onTelemetryChange, overscan, rows, rowSelectionColumn, tabBehavior, copyWithHeaders, onCopy, copyToClipboard, messages, viewportHeight, }: InspectionGridProps): react_jsx_runtime.JSX.Element;
 
+/**
+ * Input passed to a {@link LabeledGridSurface} format function.
+ *
+ * @beta
+ */
 interface LabeledGridSurfaceFormatValueInput<TRow extends PretableRow = PretableRow> {
     column: PretableColumn<TRow>;
     row: TRow;
     value: unknown;
 }
+/**
+ * Props for {@link LabeledGridSurface}.
+ *
+ * @beta
+ */
 interface LabeledGridSurfaceProps<TRow extends PretableRow = PretableRow> {
     ariaLabel: string;
     bodyCellClassName?: string;
@@ -195,46 +434,56 @@ interface LabeledGridSurfaceProps<TRow extends PretableRow = PretableRow> {
     getBodyCellProps?: (input: LabeledGridSurfaceFormatValueInput<TRow>) => HTMLAttributes<HTMLDivElement> | undefined;
     getHeaderCellProps?: (input: {
         column: PretableColumn<TRow>;
-        sortDirection: PretableSurfaceSortDirection;
+        sortDirection: PretableSortDirection;
     }) => HTMLAttributes<HTMLButtonElement> | undefined;
     getRowId?: PretableGridOptions<TRow>["getRowId"];
     headerCellClassName?: string;
-    interactionState?: PretableSurfaceProps<TRow>["interactionState"];
+    state?: PretableSurfaceProps<TRow>["state"];
     labelClassName?: string;
     overscan?: number;
     onSelectedRowIdChange?: (rowId: string | null) => void;
+    onSelectionChange?: PretableSurfaceProps<TRow>["onSelectionChange"];
+    onFocusChange?: PretableSurfaceProps<TRow>["onFocusChange"];
     onSortChange?: PretableSurfaceProps<TRow>["onSortChange"];
+    onColumnWidthsChange?: PretableSurfaceProps<TRow>["onColumnWidthsChange"];
+    onColumnOrderChange?: PretableSurfaceProps<TRow>["onColumnOrderChange"];
+    onColumnPinnedChange?: PretableSurfaceProps<TRow>["onColumnPinnedChange"];
     onTelemetryChange?: (telemetry: PretableTelemetry) => void;
     pinnedClassName?: string;
     rowClassName?: string;
     rows: TRow[];
+    rowSelectionColumn?: PretableSurfaceProps<TRow>["rowSelectionColumn"];
     selectFocusedRowOnArrowKey?: boolean;
+    tabBehavior?: PretableSurfaceProps<TRow>["tabBehavior"];
+    copyWithHeaders?: PretableSurfaceProps<TRow>["copyWithHeaders"];
+    onCopy?: PretableSurfaceProps<TRow>["onCopy"];
+    copyToClipboard?: PretableSurfaceProps<TRow>["copyToClipboard"];
+    messages?: PretableSurfaceProps<TRow>["messages"];
     valueClassName?: string;
     viewportHeight: number;
 }
-declare function LabeledGridSurface<TRow extends PretableRow = PretableRow>({ ariaLabel, bodyCellClassName, columns, formatValue, getBodyCellProps, getHeaderCellProps, getRowId, headerCellClassName, interactionState, labelClassName, overscan, onSelectedRowIdChange, onSortChange, onTelemetryChange, pinnedClassName, rowClassName, rows, selectFocusedRowOnArrowKey, valueClassName, viewportHeight, }: LabeledGridSurfaceProps<TRow>): react_jsx_runtime.JSX.Element;
-type PretableSurfaceSortDirection = NonNullable<Parameters<NonNullable<PretableSurfaceProps["renderHeaderCell"]>>[0]["sortDirection"]> | null;
-
-interface DensityHeights {
-    rowHeight: number;
-    headerHeight: number;
-}
 /**
- * React hook — reactive density values that update when `[data-density]`,
- * `[data-theme]`, `class`, or inline `style` change on `<html>`.
- *
- * Numeric props win when passed; otherwise CSS variables; otherwise fallbacks.
+ * Special-purpose surface for label/value-style table layouts. Experimental — shape may change before 1.0.
  *
- * Currently the engine only uses `headerHeight` (replaces the legacy
- * HEADER_HEIGHT constant). The `rowHeight` value is exposed for API parity
- * with the spec's documented contract and for future use; row sizing in v0.0.1
- * remains measurement-driven via `measureRenderedRowHeight()` /
- * `estimateRowHeight()`.
+ * @beta
+ */
+declare function LabeledGridSurface<TRow extends PretableRow = PretableRow>({ ariaLabel, bodyCellClassName, columns, formatValue, getBodyCellProps, getHeaderCellProps, getRowId, headerCellClassName, state, labelClassName, overscan, onSelectedRowIdChange, onSelectionChange, onFocusChange, onSortChange, onColumnWidthsChange, onColumnOrderChange, onColumnPinnedChange, onTelemetryChange, pinnedClassName, rowClassName, rows, rowSelectionColumn, selectFocusedRowOnArrowKey, tabBehavior, copyWithHeaders, onCopy, copyToClipboard, messages, valueClassName, viewportHeight, }: LabeledGridSurfaceProps<TRow>): react_jsx_runtime.JSX.Element;
+
+/**
+ * React hook returning the current density heights derived from the
+ * active CSS theme. Internal — `<Pretable>` and `<PretableSurface>` use
+ * this; external consumers should reach for `getDensityHeights` from
+ * `@pretable/ui`.
  *
- * SSR-safe: server snapshot returns fallback values without DOM access.
+ * @internal
  */
 declare function useResolvedHeights(rowHeightProp?: number, headerHeightProp?: number): DensityHeights;
 
+/**
+ * DOM measurement helper used internally by the surface's row-height accounting. Not part of the user-facing API.
+ *
+ * @internal
+ */
 declare function measureRenderedRowHeight(row: HTMLElement): number;
 
-export { type DensityHeights, InspectionGrid, type InspectionGridProps, LabeledGridSurface, type LabeledGridSurfaceFormatValueInput, type LabeledGridSurfaceProps, Pretable, type PretableModel, type PretableProps, type PretableRenderRow, type PretableRenderSnapshot, PretableSurface, type PretableSurfaceProps, type PretableTelemetry, type UsePretableModelOptions, type UsePretableOptions, measureRenderedRowHeight, usePretable, usePretableModel, useResolvedHeights };
+export { type CopyPayload, InspectionGrid, type InspectionGridProps, LabeledGridSurface, type LabeledGridSurfaceFormatValueInput, type LabeledGridSurfaceProps, Pretable, type PretableCellRenderInput, type PretableColumn, type PretableHeaderRenderInput, type PretableModel, type PretableProps, type PretableRenderRow, type PretableRenderSnapshot, PretableSurface, type PretableSurfaceMessages, type PretableSurfaceProps, type PretableSurfaceState, type PretableTelemetry, type RowSelectionColumnConfig, type SerializeRangesArgs, type UsePretableOptions, defaultCoerceForCopy, serializeRangesAsTsv, usePretable, ROW_SELECT_COLUMN_ID as ɵROW_SELECT_COLUMN_ID, measureRenderedRowHeight as ɵmeasureRenderedRowHeight, useResolvedHeights as ɵuseResolvedHeights };