@servicetitan/anvil2 3.15.0 → 3.15.2

package/dist/src/beta/components/Table/DataTable/internal/DataTableBodyRow.d.ts

@@ -1,47 +1,76 @@
 import { Row } from '@tanstack/react-table';
 import { useColumnOrder } from './useColumnOrder';
 export type DataTableBodyRowProps<T> = {
+    /**
+     * Column-order identity for `areRowPropsEqual` only. Render uses
+     * `columnIndexMap`; a new array still re-renders after pin/reorder.
+     */
     columnOrder: ReturnType<typeof useColumnOrder>["columnOrder"];
     /**
-     * O(1) lookup of leaf-column-index → visual position. Replaces
-     * `columnOrder.indexOf(...)` per cell to keep large-table renders cheap.
+     * O(1) leaf-column-index → visual position. Avoids
+     * `columnOrder.indexOf(...)` per cell.
      */
     columnIndexMap: ReturnType<typeof useColumnOrder>["columnIndexMap"];
+    /** TanStack row. `id` is `data-row-id`; `original.subComponent` is the sibling slot. */
     row: Row<T>;
+    /**
+     * Index among header + body rows (headers counted first). Converted to
+     * 1-based `aria-rowindex`.
+     */
     rowIndex: number;
+    /**
+     * Table-wide grouping flag. Gates `aria-expanded` / `aria-level` even when
+     * this row cannot expand.
+     */
     tableHasSubRows: boolean;
+    /**
+     * When true: `aria-expanded` if this row can expand, and the sibling
+     * `subComponent` slot if `original` has one.
+     */
     isExpanded: boolean;
+    /** With `tableHasSubRows`, exposes `aria-expanded`. */
     canExpand: boolean;
+    /**
+     * Nesting level (0 = root). When greater than 0, sets `--a2-row-depth` for
+     * indent on the expand-arrow and first data cell.
+     */
     depth: number;
+    /**
+     * Parent can expand. Nested leaves still get `aria-level` when the table
+     * has subrows.
+     */
     parentRowCanExpand: boolean;
+    /**
+     * `isSelected`, `isSomeSelected`, and `isAncestorSelected` OR together for
+     * `data-anv-is-selected-row` (full, indeterminate, and inherited paint).
+     */
     isSelected: boolean;
+    /** Some but not all descendants selected. */
     isSomeSelected: boolean;
     /**
-     * True when any ancestor row (parent, grandparent, etc.) is currently
-     * selected. Combined with `isSelected` to drive the row's
-     * `data-anv-is-selected-row` attribute so descendants visually adopt
-     * an ancestor's selection state without painting the ancestor itself.
-     * Computed at the parent level (`DataTableBody.tsx`) so the prop
-     * remains a serializable boolean — preserving `React.memo`
-     * comparator semantics in `areRowPropsEqual`.
+     * Passed as a boolean so `areRowPropsEqual` stays a cheap identity check
+     * instead of walking ancestors per compare.
      */
     isAncestorSelected: boolean;
     /**
-     * True when the row is flagged read-only via `readOnlyRowIds`. Grays the
-     * row's plain-text cell content. Checkbox disabling is gated separately
-     * at the DataTable level via `enableRowSelection`.
+     * From `readOnlyRowIds`. Grays plain-text cells; skips the row-click
+     * handler and affordance. Checkbox disabling is gated separately via
+     * `enableRowSelection`.
      */
     isReadOnly: boolean;
     /**
-     * Optional consumer-provided function that returns a value expressing
-     * "this row has changed." When supplied, the row is memoized: a row will
-     * only re-render when the returned value differs from the previous render,
-     * the row's internal UI state changes (expansion, selection, etc.), or
-     * any row it depends on changes structurally. When omitted, every row
-     * re-renders whenever the parent re-renders.
+     * Opt-in memo key. When omitted, the row always re-renders with its parent.
+     * When set, skip re-render only if this value and the table-managed props
+     * compared in `areRowPropsEqual` are unchanged. Include any extra-row
+     * input the cells read (for example a highlight id).
      */
     getRowVersion?: (row: T) => unknown;
 };
 declare function DataTableBodyRowInner<T>({ columnOrder: _columnOrder, columnIndexMap, row, rowIndex, tableHasSubRows, isExpanded, canExpand, depth, parentRowCanExpand, isSelected, isSomeSelected, isAncestorSelected, isReadOnly, }: DataTableBodyRowProps<T>): import("react/jsx-runtime").JSX.Element;
+/**
+ * One body row plus an optional sibling `subComponent` slot. Hover and
+ * selection paint via data attributes (including descendants) so they stay
+ * off the React render path. Memoization is opt-in through `getRowVersion`.
+ */
 export declare const DataTableBodyRow: typeof DataTableBodyRowInner;
 export {};

package/dist/src/beta/components/Table/DataTable/internal/DataTableCellAffordance.d.ts

@@ -1,6 +1,14 @@
 import { ReactNode } from 'react';
 export type DataTableCellAffordanceProps = {
     children: ReactNode;
+    /**
+     * Lets the overlay receive pointer events. Defaults to `false` (display-only
+     * icons such as edit).
+     */
     interactive?: boolean;
 };
+/**
+ * Decorative overlay shown on a host cell's hover/focus. Hidden from the
+ * accessibility tree.
+ */
 export declare function DataTableCellAffordance({ children, interactive, }: DataTableCellAffordanceProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/beta/components/Table/DataTable/internal/DataTableFooter.d.ts

@@ -2,47 +2,41 @@ import { ComponentPropsWithoutRef } from 'react';
 import { Table as TanstackTable } from '@tanstack/react-table';
 import { ColumnDef } from '../../types';
 import { DataTableProps, DataTableRowData } from '../DataTable';
-/**
- * Props for the default/configured table footer rows
- * @extends TanstackTable<T>
- * @extends ColumnDef<T>[]
- */
 export type DefaultTableFooterRowsProps<T extends DataTableRowData> = {
+    /** Supplies header/row counts for `aria-rowindex` and the visual column order. */
     table: TanstackTable<T>;
+    /**
+     * Column tree used to look up `footerContent` on leaves. Group columns are
+     * skipped so nested headers do not get a footer cell.
+     */
     columns: ColumnDef<T>[];
 };
-/**
- * Props for the custom table footer rows
- * @extends DataTableProps<T>
- */
 export type CustomTableFooterRowsProps<T extends DataTableRowData> = {
+    /**
+     * Visible leaf header count (`table.getFlatHeaders().length`).
+     */
     columnCount: number;
+    /** Row-major `{ content, colSpan }` cells for the custom path. */
     customFooter: DataTableProps<T>["customFooter"];
+    /** Supplies header/row counts for `aria-rowindex`. */
     table: TanstackTable<T>;
 };
-/**
- * Props for the DataTableFooter component
- * @extends ComponentPropsWithoutRef<"div">
- */
 export type DataTableFooterProps<T extends DataTableRowData> = {
-    /**
-     * The table instance from @tanstack/react-table to render
-     */
+    /** Supplies header/row counts for `aria-rowindex` and the visual column order. */
     table: TanstackTable<T>;
     /**
-     * The columns of the table
+     * Column tree for leaf `footerContent`. Array values become extra rows; a
+     * scalar fills row 0.
      */
     columns: ColumnDef<T>[];
     /**
-     * The custom footer of the table
+     * Row-major custom cells. When set (even empty), this path is used instead
+     * of column `footerContent`.
      */
     customFooter?: DataTableProps<T>["customFooter"];
 } & ComponentPropsWithoutRef<"div">;
 /**
- * Data table footer, which can be either a configured or custom footer
- * @param props - The props for the DataTableFooter component
- * @param props.table - The table instance from @tanstack/react-table to render
- * @param props.customFooter - The custom footer of the table
- * @param props.columns - The columns of the table
+ * Footer region. `customFooter` replaces column `footerContent` when set.
+ * `aria-rowindex` continues after header and body rows.
  */
 export declare function DataTableFooter<T extends DataTableRowData>({ table, customFooter, columns, ...rest }: DataTableFooterProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/src/beta/components/Table/DataTable/internal/DataTableHeader.d.ts

@@ -1,19 +1,16 @@
 import { ComponentPropsWithoutRef, RefObject } from 'react';
 import { Table as TanstackTable } from '@tanstack/react-table';
-/**
- * Props for the DataTableHeader component
- * @extends TanstackTable<T>
- * @extends ComponentPropsWithoutRef<"div">
- */
 type DataTableHeaderProps<T> = {
+    /** Supplies header groups plus column sorting, sizing, and metadata. */
     table: TanstackTable<T>;
+    /**
+     * Table root used to scope imperative column-hover attributes to this table.
+     */
     tableRef: RefObject<HTMLDivElement>;
 } & ComponentPropsWithoutRef<"div">;
 /**
- * Data table header container
- * @param props - The props for the DataTableHeader component
- * @param props.table - The table instance from @tanstack/react-table to render
- * @param props.tableRef - Ref to the table root element for imperative DOM writes
+ * Renders DataTable header rows from TanStack header groups, including group
+ * spans, sort indicators, and column resize handles.
  */
 export declare function DataTableHeader<T>({ table, tableRef, }: DataTableHeaderProps<T>): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/src/beta/components/Table/DataTable/internal/DataTablePagination.d.ts

@@ -1,9 +1,25 @@
 import { PaginationProps } from '../../../../../components/Pagination';
 type DataTableCursorPaginationProps = Pick<PaginationProps, "page" | "itemsPerPage" | "onPageChange" | "onItemsPerPageChange" | "itemsPerPageOptions"> & {
+    /** Explicit `true` enables Next. Omitted or false leaves it disabled. */
     hasNextPage?: boolean;
+    /**
+     * Explicit `true` enables Previous when `page` is greater than 1. Omitted
+     * or false leaves it disabled.
+     */
     hasPrevPage?: boolean;
 };
+/**
+ * Numbered pagination fields picked from {@link PaginationProps}, including
+ * `totalItemCount`.
+ */
 export type DataTablePaginationProps = Pick<PaginationProps, "page" | "itemsPerPage" | "totalItemCount" | "showCount" | "onPageChange" | "onItemsPerPageChange" | "itemsPerPageOptions">;
+/**
+ * Numbered page chrome for DataTable. `showCount` defaults to `true`.
+ */
 export declare const DataTablePagination: ({ showCount, ...props }: DataTablePaginationProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Prev/next chrome when the table has no `totalItemCount`. Next/Previous stay
+ * disabled unless the matching flag is exactly `true`.
+ */
 export declare const DataTableCursorPagination: ({ page, itemsPerPage, itemsPerPageOptions, hasNextPage, hasPrevPage, onPageChange, onItemsPerPageChange, }: DataTableCursorPaginationProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/src/beta/components/Table/DataTable/internal/cells/CellFocusContext.d.ts

@@ -1,16 +1,7 @@
 export type CellFocusContextValue = {
-    /**
-     * Whether the cell currently has focus
-     */
+    /** True while the owning cell holds keyboard or pointer focus. */
     isCellFocused: boolean;
 };
-/**
- * Context for communicating cell focus state to child components.
- * Used by CellStatus to show tooltips when the cell is focused via keyboard.
- */
 export declare const CellFocusContext: import('react').Context<CellFocusContextValue | null>;
-/**
- * Hook to consume the CellFocusContext.
- * Returns null if used outside of a CellFocusContext.Provider.
- */
+/** Reads the optional cell-focus bag. */
 export declare function useCellFocusContext(): CellFocusContextValue | null;

package/dist/src/beta/components/Table/DataTable/internal/cells/CellStatus.d.ts

@@ -1,12 +1,14 @@
 export type CellStatusProps = {
-    /** Status value - true for status without message, string for status with accessible message */
+    /**
+     * `true` shows the icon only. A string is the tooltip and is appended to the
+     * icon's accessible name.
+     */
     status: boolean | string;
-    /** The variant determines the icon, color, and aria-label */
+    /** Picks the icon, color, and default accessible name. */
     variant: "error" | "warning";
 };
 /**
- * Renders a status icon (error or warning) for cells.
- * When status is a string, it's used as the aria-label for accessibility and shown in a tooltip.
- * When the parent cell is focused, the tooltip is displayed for keyboard accessibility.
+ * Error or warning icon for a cell. A string `status` also opens a tooltip
+ * while the cell is focused or the icon is hovered.
  */
 export declare function CellStatus({ status, variant }: CellStatusProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/beta/components/Table/DataTable/internal/cells/DataTableBodyCell.d.ts

@@ -3,18 +3,14 @@ import { Cell } from '@tanstack/react-table';
 import { ReactNode } from 'react';
 import { CellPosition } from '../../../internal/types';
 export type DataTableBodyCellProps<T> = Omit<BaseDataTableBodyCellProps, "onChange"> & {
+    /** Grid coordinates used for roving tabindex and `data-cell-pos`. */
     cellPosition: CellPosition;
+    /** TanStack cell; column meta chooses the renderer. */
     cell: Cell<T, unknown>;
     children: ReactNode;
 };
 /**
- * Renders a body cell in a DataTable, delegating to either a mutable (editable) or immutable cell
- * based on the column's editMode configuration.
- *
- * @param props - The props for the DataTableBodyCell component
- * @param props.cell - The TanStack table cell instance
- * @param props.cellPosition - The position of the cell in the table
- * @param props.children - The content to render in the cell
- * @returns The rendered cell component
+ * Body-cell dispatcher: editable when `editMode` is set, overflow surface when
+ * `overflow.mode` is `"surface"`, otherwise the immutable cell.
  */
 export declare function DataTableBodyCell<T>(props: DataTableBodyCellProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/src/beta/components/Table/DataTable/internal/cells/DataTableBodyImmutableCell.d.ts

@@ -1,27 +1,14 @@
 import { DataTableBodyCellProps as BaseDataTableBodyCellProps } from '../../../base/cells/TableBodyCell';
 import { Cell } from '@tanstack/react-table';
 import { CellPosition } from '../../../internal/types';
-/**
- * Props for the DataTableBodyImmutableCell component
- */
 export type DataTableBodyImmutableCellProps<T> = Omit<BaseDataTableBodyCellProps, "onChange"> & {
-    /**
-     * The position of the cell in the table
-     */
+    /** Coordinates used by the grid's roving-focus manager. */
     cellPosition: CellPosition;
-    /**
-     * The TanStack table cell instance
-     */
+    /** Supplies row and column state for actions and validation styling. */
     cell: Cell<T, unknown>;
 };
 /**
- * Renders an immutable (non-editable) body cell in a DataTable. This component handles keyboard
- * navigation for focus management and row expansion/selection, but does not support cell editing.
- *
- * @param props - The props for the DataTableBodyImmutableCell component
- * @param props.cell - The TanStack table cell instance
- * @param props.cellPosition - The position of the cell in the table
- * @param props.children - The content to render in the cell
- * @returns The rendered immutable cell component
+ * Read-only ARIA grid cell with roving navigation and keyboard activation for
+ * row actions or embedded controls.
  */
 export declare function DataTableBodyImmutableCell<T>(props: DataTableBodyImmutableCellProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/src/beta/components/Table/DataTable/internal/cells/DataTableBodyMutableCell.d.ts

@@ -1,28 +1,14 @@
 import { DataTableBodyCellProps as BaseDataTableBodyCellProps } from '../../../base/cells/TableBodyCell';
 import { Cell } from '@tanstack/react-table';
 import { CellPosition } from '../../../internal/types';
-/**
- * Props for the DataTableBodyMutableCell component
- */
 export type DataTableBodyMutableCellProps<T> = Omit<BaseDataTableBodyCellProps, "onChange"> & {
-    /**
-     * The position of the cell in the table
-     */
+    /** Coordinates used by the grid's roving-focus manager. */
     cellPosition: CellPosition;
-    /**
-     * The TanStack table cell instance
-     */
+    /** Supplies row and column state for the configured editor and validation styling. */
     cell: Cell<T, unknown>;
 };
 /**
- * Renders a mutable (editable) body cell in a DataTable. This component handles keyboard navigation
- * and delegates to the appropriate editable cell component (text, select, or multiselect) based on
- * the column's editMode configuration.
- *
- * @param props - The props for the DataTableBodyMutableCell component
- * @param props.cell - The TanStack table cell instance
- * @param props.cellPosition - The position of the cell in the table
- * @param props.children - The content to render in the cell
- * @returns The rendered editable cell component or null if no editMode is configured
+ * Editable ARIA grid cell with roving navigation. Delegates to the editor
+ * configured by the column and invokes it with Enter, Space, or F2.
  */
 export declare function DataTableBodyMutableCell<T>(props: DataTableBodyMutableCellProps<T>): import("react/jsx-runtime").JSX.Element | null;

package/dist/src/beta/components/Table/DataTable/internal/cells/DataTableFooterCell.d.ts

@@ -1,20 +1,13 @@
 import { DataTableFooterCellProps as BaseDataTableFooterCellProps } from '../../../base/cells/TableFooterCell';
-/**
- * Props for the DataTableFooterCell component
- * @extends BaseDataTableFooterCellProps
- */
 export type DataTableFooterCellProps = BaseDataTableFooterCellProps & {
+    /** Grid coordinates used for roving tabindex and `data-cell-pos`. */
     cellPosition: {
         rowIndex: number;
         columnIndex: number;
     };
 };
 /**
- * Data table footer cell with focus management
- * @param props - The props for the DataTableFooterCell component
- * @param props.cellPosition - The cell position of the cell
- * @param props.children - The children of the DataTableFooterCell component
- * @param props.className - The class name of the DataTableFooterCell component
- * @param props.tabIndex - The tab index of the cell
+ * Footer gridcell. Tabindex is written by `DTFocusProvider`; this cell only
+ * handles arrow/Home/End movement.
  */
 export declare function DataTableFooterCell(props: DataTableFooterCellProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/beta/components/Table/DataTable/internal/cells/DataTableHeaderCell.d.ts

@@ -1,29 +1,17 @@
 import { Ref } from 'react';
 import { HeaderContext } from '@tanstack/react-table';
 import { DataTableHeaderCellProps as BaseDataTableHeaderCellProps } from '../../../base/cells/TableHeaderCell';
-/**
- * Props for the DataTableHeaderCell component
- * @extends BaseDataTableHeaderCellProps
- */
 export type DataTableHeaderCellProps<T, TValue> = BaseDataTableHeaderCellProps & {
+    /** Coordinates used by the grid's roving-focus manager. */
     cellPosition: {
         rowIndex: number;
         columnIndex: number;
     };
+    /** Supplies column actions and sort state for this rendered header. */
     header: HeaderContext<T, TValue>;
 };
-/**
- * Data table header cell with focus management
- * @param props - The props for the DataTableHeaderCell component
- * @param props.cellPosition - The cell position of the cell
- * @param props.children - The children of the DataTableHeaderCell component
- * @param props.header - The header of the DataTableHeaderCell component
- * @param props.isFocused - Whether the cell is focused
- */
 declare function DataTableHeaderCellInner<T, TValue>(props: DataTableHeaderCellProps<T, TValue>, forwardedRef: Ref<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
-/**
- * Data table header cell with focus management and ref forwarding
- */
+/** ARIA grid header cell with roving focus and column-specific actions. */
 export declare const DataTableHeaderCell: <T, TValue>(props: DataTableHeaderCellProps<T, TValue> & {
     ref?: Ref<HTMLDivElement>;
 }) => ReturnType<typeof DataTableHeaderCellInner>;

package/dist/src/beta/components/Table/DataTable/internal/cells/DataTableOverflowCell.d.ts

@@ -1,2 +1,6 @@
 import { DataTableBodyImmutableCellProps } from './DataTableBodyImmutableCell';
+/**
+ * Read-only ARIA grid cell that opens clipped content in a disclosure surface.
+ * Supports pointer activation and the grid's disclosure and navigation keys.
+ */
 export declare function DataTableOverflowCell<T>(props: DataTableBodyImmutableCellProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/src/beta/components/Table/DataTable/internal/cells/useCellFocusListener.d.ts

@@ -1,10 +1,6 @@
 import { RefObject } from 'react';
 /**
- * Tracks whether the nearest DataTable cell ancestor of `elementRef` is focused.
- * Replaces CellFocusContext for status cells — avoids a React context for the
- * common case while keeping reactive state where needed (tooltip visibility).
- *
- * @param elementRef Ref to the element whose cell-focus state we want to track.
- * @returns True when the cell ancestor currently contains document.activeElement.
+ * Whether the nearest `[data-anv="table-body-cell"]` ancestor currently
+ * contains focus. Starts `false` until a `focusin` on that cell.
  */
 export declare function useCellFocusListener(elementRef: RefObject<HTMLElement>): boolean;

package/dist/src/beta/components/Table/DataTable/internal/constants.d.ts

@@ -1,48 +1,31 @@
 /**
- * Internal column ID for the primary row action column.
- * This column typically contains expand buttons, but may also contain
- * checkboxes for nested rows when selection is enabled.
+ * Expand-arrow column.
  */
 export declare const INTERNAL_ROW_ACTION_PRIMARY_COLUMN_ID = "a2-table-internal-row-action-primary";
 /**
- * Internal column ID for the secondary row action column.
- * This column contains checkboxes for row selection when enabled.
- * For nested rows, this column renders nothing (selection is handled
- * in the primary action column instead).
+ * Row-selection checkbox column.
  */
 export declare const INTERNAL_ROW_ACTION_SECONDARY_COLUMN_ID = "a2-table-internal-row-action-secondary";
 /**
- * Initial per-row height estimate used before measurement. Individual rows are
- * measured via `measureElement` and corrected after first paint, so this value
- * only affects the pre-measurement scroll range.
+ * Per-row height for the virtualizer `estimateSize` and the first-load spacer
+ * (`rowsPerPage * this`, then clamped). Measurement replaces it after first
+ * paint, so it only shapes the pre-measurement scroll range and spacer.
  */
 export declare const DEFAULT_ESTIMATED_ROW_HEIGHT = 35;
 /**
- * Upper bound for the estimated loading spacer height on the first load.
- *
- * The estimate is `rowsPerPage * DEFAULT_ESTIMATED_ROW_HEIGHT`, which is taller
- * than most viewports at large page sizes (1750px at 50 rows per page) and
- * renders as a large empty area with a spinner in it. There is no real height
- * to preserve before the body has been measured, so cap the estimate at
- * something that still reads as a table.
+ * Ceiling for the first-load loading spacer. Uncapped `rowsPerPage * estimated
+ * row height` is taller than the viewport at large page sizes and leaves a
+ * tall empty spinner well.
  */
 export declare const MAX_INITIAL_LOADING_HEIGHT = 400;
 /**
- * Lower bound for the estimated loading spacer height on the first load.
- *
- * The spacer centers a medium `Spinner`, which is 40px square, so a very small
- * page size would otherwise render a spacer too short to contain its own
- * spinner (35px at `rowsPerPage: 1`). Leave room for it.
+ * Floor for the first-load loading spacer so a small page size still contains
+ * the centered medium Spinner.
  */
 export declare const MIN_INITIAL_LOADING_HEIGHT = 80;
 /**
- * Loading spacer height used on the first load when the page size cannot be
- * turned into an estimate.
- *
- * `rowsPerPage` comes from `paginationObject?.rowsPerPage ?? 25`, and `??` only
- * substitutes for null and undefined — an explicit `0`, a negative, or a `NaN`
- * parsed from user input all survive it. Multiplying any of them out would
- * render `0px`, a negative height, or `NaNpx`, collapsing the spacer that this
- * exists to prevent.
+ * First-load spacer height when `rowsPerPage` is not a positive number.
+ * `paginationObject?.rowsPerPage ?? 25` only replaces nullish values, so `0`,
+ * negatives, and `NaN` skip the estimated-height clamp and use this instead.
  */
 export declare const DEFAULT_INITIAL_LOADING_HEIGHT = 200;

package/dist/src/beta/components/Table/DataTable/internal/context/focus/DTFocusContext.d.ts

@@ -1,12 +1,7 @@
 import { CellPosition } from '../../../../internal/types';
 export type DTFocusState = {
-    /**
-     * The currently focused cell or null if no cell is focused
-     */
     focusedCell: CellPosition | null;
-    /**
-     * The last focused cell when the table was blurred or { rowIndex: 0, columnIndex: 0 } if never focused
-     */
+    /** Cell that receives focus when the grid root is entered. */
     focusRestorePoint: CellPosition;
 };
 export type DTFocusStateContextValue = {

package/dist/src/beta/components/Table/DataTable/internal/context/focus/DTFocusProvider.d.ts

@@ -9,4 +9,7 @@ export interface DTFocusProviderProps {
     virtualizer?: DataTableVirtualizer;
     headerRowCount: number;
 }
+/**
+ * Coordinates roving focus across rendered and virtualized data-table cells.
+ */
 export declare function DTFocusProvider({ children, rowCount, columnCount, tableRef, leftPinnedWidth, rightPinnedWidth, virtualizer, headerRowCount, }: DTFocusProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/beta/components/Table/DataTable/internal/context/focus/useDTFocusDispatchContext.d.ts

@@ -1,4 +1,5 @@
 import { CellPosition } from '../../../../internal/types';
+/** Returns focus commands from the nearest data-table focus provider. */
 export declare function useDTFocusDispatchContext(): {
     focusTableGenerally: () => void;
     moveFocusToCell: (cellPosition: CellPosition) => void;

package/dist/src/beta/components/Table/DataTable/internal/context/focus/useDTFocusStateContext.d.ts

@@ -1 +1,2 @@
+/** Returns a non-reactive getter for the latest focused cell. */
 export declare function useDTFocusStateContext(): import('./DTFocusContext').DTFocusStateContextValue;

package/dist/src/beta/components/Table/DataTable/internal/context/rowClick/DataTableRowClickContext.d.ts

@@ -1,10 +1,7 @@
 export type DataTableRowClickContextValue = {
-    /** Whether an `onClickRow` handler is set on the DataTable. */
+    /** Enables row-click affordances when the consumer supplied a handler. */
     isRowClickEnabled: boolean;
-    /**
-     * Fire the row-click callback for the given (TanStack) row id. No-ops when
-     * row click is disabled or the row is read-only.
-     */
+    /** Invokes the latest callback when present unless the row is read-only. */
     clickRow: (rowId: string) => void;
 };
 export declare const DataTableRowClickContext: import('react').Context<DataTableRowClickContextValue>;

package/dist/src/beta/components/Table/DataTable/internal/context/rowClick/DataTableRowClickProvider.d.ts

@@ -10,10 +10,7 @@ export type DataTableRowClickProviderProps = {
     children: ReactNode;
 };
 /**
- * Provides a stable, ref-backed `clickRow` to the DataTable body (rows handle
- * pointer clicks; immutable cells handle Enter). Keeping `clickRow` identity
- * stable means consuming rows/cells never re-render just because the consumer
- * passed a new `onClickRow` reference, while the ref read always sees the
- * latest handler and read-only map.
+ * Keeps `clickRow` stable while reading the latest callback and read-only map
+ * from refs.
  */
 export declare function DataTableRowClickProvider({ onClickRow, readOnlyRowMap, children, }: DataTableRowClickProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/beta/components/Table/DataTable/internal/context/rowClick/useDataTableRowClick.d.ts

@@ -1 +1,2 @@
+/** Defaults to disabled + no-op `clickRow` when no provider is mounted. */
 export declare function useDataTableRowClick(): import('./DataTableRowClickContext').DataTableRowClickContextValue;

package/dist/src/beta/components/Table/DataTable/internal/context/surface/DataTableSurfaceCoordinatorContext.d.ts

@@ -1,13 +1,17 @@
 import { RefObject } from 'react';
 export type DataTableSurfaceRegistration = {
     id: string;
+    /** Closes the surface, optionally suppressing focus restoration. */
     close: (options?: {
         restoreFocus?: boolean;
     }) => void;
 };
 export type DataTableSurfaceCoordinator = {
+    /** Closes the previous surface without restoring focus, then registers this one. */
     requestOpen: (registration: DataTableSurfaceRegistration) => void;
+    /** Clears the active registration only when its id matches. */
     clear: (id: string) => void;
+    /** After place/drag/resize, keep overlapping this element's box; DataTable passes the table container. */
     intersectionBoundaryRef?: RefObject<HTMLElement | null>;
 };
 export declare const DataTableSurfaceCoordinatorContext: import('react').Context<DataTableSurfaceCoordinator | null>;

package/dist/src/beta/components/Table/DataTable/internal/context/surface/DataTableSurfaceCoordinatorProvider.d.ts

@@ -3,5 +3,6 @@ type DataTableSurfaceCoordinatorProviderProps = {
     children: React.ReactNode;
     intersectionBoundaryRef?: RefObject<HTMLElement | null>;
 };
+/** Ensures only one cell-owned surface remains open at a time. */
 export declare function DataTableSurfaceCoordinatorProvider({ children, intersectionBoundaryRef, }: DataTableSurfaceCoordinatorProviderProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/src/beta/components/Table/DataTable/internal/context/surface/useDataTableSurfaceCoordinator.d.ts

@@ -1 +1,2 @@
+/** Returns the nearest surface coordinator, or `null` outside its provider. */
 export declare function useDataTableSurfaceCoordinator(): import('./DataTableSurfaceCoordinatorContext').DataTableSurfaceCoordinator | null;

package/dist/src/beta/components/Table/DataTable/internal/dataTableCellAffordanceHostClassName.d.ts

@@ -1 +1,2 @@
+/** Host class that reveals {@link DataTableCellAffordance} on hover or focus. */
 export declare const dataTableCellAffordanceHostClassName: any;

package/dist/src/beta/components/Table/DataTable/internal/editable-cells/DataTableEditableBooleanCell.d.ts

@@ -1,5 +1,11 @@
 import { EditableCellImperativeHandle, BaseEditableCellProps } from './types';
 export type DataTableEditableBooleanCellProps<T> = BaseEditableCellProps<T>;
+/**
+ * Menu editor for boolean cells. Missing boolean `editConfig`, or a value that
+ * is neither boolean nor nullish, falls back to a read-only body cell. Labels
+ * prefer `editConfig`, then formatter options, then True/False; Unset only when
+ * `allowNull`.
+ */
 export declare const DataTableEditableBooleanCell: (<T>(props: DataTableEditableBooleanCellProps<T> & {
     ref?: React.Ref<EditableCellImperativeHandle>;
 }) => React.ReactElement) & {