@servicetitan/anvil2 3.15.0 → 3.15.2

package/dist/src/beta/components/SavedFiltersButton/SavedFiltersButton.d.ts

@@ -1,38 +1,7 @@
 import { SavedFiltersButtonProps } from './types';
 /**
- * `SavedFiltersButton` is an opt-in companion to FilterBar that lets users
- * apply, save, edit, and delete preset filter selections. It is fully
- * stateless: the consumer owns the `savedFilters` array and writes its own
- * persistence (server, localStorage, etc.) by reacting to the callbacks the
- * component fires.
- *
- * Visually it's a single Button trigger that opens a popover listing the
- * presets, with two footer actions:
- *
- * - **Save Current Filter** opens a drawer that snapshots `currentFilters`
- *   into a new preset.
- * - **Edit Saved Filters** opens a drawer listing every preset with edit
- *   affordances; clicking edit on a row drills into a per-preset form
- *   reusing the FilterBar adapter `renderDrawer` machinery.
- *
- * Apply, save, update, and delete are all delivered as consumer callbacks
- * (`onApplySavedFilter`, `onSaveCurrentFilter`, `onUpdateSavedFilter`,
- * `onDeleteSavedFilter`). Promise-returning callbacks are supported with
- * loading state on the relevant submit button and success/error alerts on
- * the parent drawer.
- *
- * @example
- * <SavedFiltersButton
- *   savedFilters={presets}
- *   currentFilters={filters}
- *   onApplySavedFilter={(preset) => setFilters(preset.filters)}
- *   onSaveCurrentFilter={async ({ name, filters }) => {
- *     await api.savePreset({ name, filters });
- *     refetchPresets();
- *   }}
- *   onUpdateSavedFilter={async (id, update) => api.updatePreset(id, update)}
- *   onDeleteSavedFilter={async (id) => api.deletePreset(id)}
- * />
+ * Consumer-controlled companion for applying and managing FilterBar presets.
+ * Saving and editing open drawer flows while persistence remains external.
  */
 export declare const SavedFiltersButton: {
     (props: SavedFiltersButtonProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/beta/components/SavedFiltersButton/internal/AddSavedFilterDrawer.d.ts

@@ -2,26 +2,16 @@ import { Filter } from '../../FilterBar/internal/types';
 type AddSavedFilterDrawerProps = {
     open: boolean;
     onClose: () => void;
-    /** Snapshot of filters captured when the drawer opened. */
     filtersSnapshot: Filter[];
     onSave: (payload: {
         name: string;
         filters: Filter[];
     }) => void | Promise<void>;
-    /**
-     * Consumer-supplied name validator. Returning a string blocks Add and is
-     * surfaced as the field's error message; `undefined` allows submit.
-     */
     validateName?: (name: string) => string | undefined;
 };
 /**
- * Drawer rendered when the user clicks "Save Current Filter" in the
- * SavedFiltersButton popover. Captures a name and emits `onSave` with the
- * filters snapshot. Supports async `onSave`; while pending the Add button
- * shows a loading spinner and the form is disabled.
- *
- * If `onSave` rejects, the drawer stays open with the current input so the
- * user can retry or cancel. On success the drawer closes.
+ * Names and submits the filter snapshot captured when the save flow opened.
+ * Rejected saves preserve the form for retry.
  */
 export declare const AddSavedFilterDrawer: ({ open, onClose, filtersSnapshot, onSave, validateName, }: AddSavedFilterDrawerProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/src/beta/components/SavedFiltersButton/internal/EditSavedFiltersDrawer.d.ts

@@ -3,36 +3,18 @@ type EditSavedFiltersDrawerProps = {
     open: boolean;
     onClose: () => void;
     savedFilters: SavedFilter[];
-    /** Drilldown's "Update Filter" action. May return a promise. */
     onUpdate?: (id: string, update: {
         name: string;
         filters: SavedFilter["filters"];
     }) => void | Promise<void>;
-    /** Drilldown's "Delete Filter" action. May return a promise. */
     onDelete?: (id: string) => void | Promise<void>;
-    /**
-     * Optional drag-to-reorder callback. When provided, the list view renders
-     * each row as a `DndSort.Card` with a drag handle and emits the new
-     * `orderedIds` after a drop. When omitted, the list renders as a static
-     * stack with no handles.
-     */
     onReorder?: (orderedIds: string[]) => void | Promise<void>;
-    /**
-     * Optional validator for the name field in the drilldown. The `currentId`
-     * is set to the preset being edited so the consumer can permit the row's
-     * own name in uniqueness checks.
-     */
     validateName?: (name: string, currentId?: string) => string | undefined;
-    /** Optional override for the auto-managed alert text. */
     alertText?: SavedFiltersAlertText;
 };
 /**
- * Drawer that lets the user manage existing saved filters. Composed of two
- * views — a list of presets (the Drawer host) and a per-preset edit screen
- * (a `DrillDown` child) that reuses the FilterBar adapter `renderDrawer`
- * machinery to render edit fields. Navigation between the two is driven by
- * `useDrillDown`, which also wires the back-button affordance built into
- * `DrillDown.Header`.
+ * Lists saved filters and opens a FilterBar-backed drilldown to update or
+ * delete a preset.
  */
 export declare const EditSavedFiltersDrawer: ({ open, onClose, savedFilters, onUpdate, onDelete, onReorder, validateName, alertText, }: EditSavedFiltersDrawerProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/src/beta/components/SavedFiltersButton/parts.d.ts

@@ -1,37 +1,14 @@
-/**
- * `data-anv-part` names for SavedFiltersButton's interactive sub-elements.
- *
- * The trigger is stamped by FilterTriggerButton (`FilterBar` PARTS.trigger) —
- * do not redeclare `trigger` here. Popover / menu / option parts come from
- * shared OptionsPopover / OptionsPanel internals.
- *
- * Scope in-wrapper queries by the consumer's `data-cy` on the trigger.
- * Drawers and their contents render in the top layer — target those parts
- * by attribute directly. Edit-row buttons also carry `data-id={preset.id}`.
- */
 export declare const PARTS: {
     readonly input: "input";
     readonly cancelButton: "cancel-button";
     readonly applyButton: "apply-button";
-    /** Popover footer CTA that opens the Save Current Filter drawer. */
     readonly saveCurrentButton: "save-current-button";
-    /** Popover footer CTA that opens the Edit Saved Filters drawer. */
     readonly manageButton: "manage-button";
-    /** Save Current Filter drawer shell. */
     readonly addDrawer: "add-drawer";
-    /** Edit Saved Filters drawer shell. */
     readonly editDrawer: "edit-drawer";
-    /**
-     * Per-preset edit drilldown screen inside the Edit drawer (visible after
-     * clicking an edit-row-button).
-     */
     readonly drilldown: "drilldown";
-    /** Per-preset Edit affordance in the Edit drawer list (use with `data-id`). */
     readonly editRowButton: "edit-row-button";
-    /** Drilldown Delete Filter action. */
     readonly deleteButton: "delete-button";
-    /** Drilldown Update Filter action. */
     readonly updateButton: "update-button";
-    /** Edit drawer list-view Close action. */
     readonly closeButton: "close-button";
 };

package/dist/src/beta/components/SavedFiltersButton/types.d.ts

@@ -2,147 +2,98 @@ import { ReactNode } from 'react';
 import { DataAttributes } from '../../../types';
 import { Filter } from '../FilterBar/internal/types';
 /**
- * A consumer-owned preset of filter values. The component never mutates these
- * — it only emits callbacks describing the user's intent (apply, save, update,
- * delete). The consumer holds the source-of-truth list and re-renders
- * `SavedFiltersButton` with the updated array.
- *
- * `filters` is a snapshot of the bar's full filter schema with the preset's
- * values baked in, in the same shape as `FilterBar`'s `filters` prop. That
- * uniformity lets the edit drilldown reuse the FilterBar adapter
- * `renderDrawer` machinery without bespoke per-filter-type rendering.
+ * Consumer-owned FilterBar preset. Mutations are requested through
+ * {@link SavedFiltersButtonProps} callbacks.
  */
 export type SavedFilter = {
+    /** Stable key used for selection, mutation, and reordering. */
     id: string;
+    /** Displayed in the preset list and edit flow. */
     name: string;
+    /** Complete FilterBar state passed on apply and seeded into the edit flow. */
     filters: Filter[];
-    /**
-     * When true, this preset cannot be edited from the Edit drawer — its row
-     * renders without an Edit affordance and the drilldown is unreachable.
-     * Useful for marking system / seeded presets as immutable while still
-     * letting users edit their own.
-     */
+    /** Removes the preset's Edit action. */
     disableEdit?: boolean;
-    /**
-     * When true, the "Delete Filter" button is omitted from the drilldown
-     * footer for this preset. Independent of `disableEdit` — a preset can be
-     * editable but not deletable, or vice versa.
-     */
+    /** Removes the Delete action from the preset's edit screen. */
     disableDelete?: boolean;
 };
 /**
- * Text overrides for the auto-managed success / error Alerts that appear on
- * the "Edit Saved Filters" drawer after a save, update, delete, or reorder
- * settles.
- *
- * All entries are optional; unset values fall back to generic defaults.
+ * Alert-title configuration for update, delete, and reorder outcomes.
+ * `saveSuccess` and `saveError` are reserved and currently unused.
  */
 export type SavedFiltersAlertText = {
+    /** Reserved and currently unused. Successful saves close without an alert. */
     saveSuccess?: string;
+    /** Reserved and currently unused. */
     saveError?: string;
+    /** List alert shown after the edit screen closes on successful update. */
     updateSuccess?: string;
+    /** Fallback title when an update rejects without an error message. */
     updateError?: string;
+    /** List alert shown after the edit screen closes on successful deletion. */
     deleteSuccess?: string;
+    /** Fallback title when deletion rejects without an error message. */
     deleteError?: string;
-    /**
-     * Surfaced on the list view when `onReorderSavedFilters` rejects. No
-     * matching `reorderSuccess` — successful reorders don't show an alert,
-     * because the new order is its own visible confirmation.
-     */
+    /** Fallback title when reordering rejects without an error message. */
     reorderError?: string;
 };
 export type SavedFiltersButtonProps = DataAttributes & {
-    /** The presets to list. Consumer owns the storage. */
+    /** Source-of-truth preset list; update it in response to mutation callbacks. */
     savedFilters: SavedFilter[];
     /**
-     * The filters currently committed in the FilterBar (or any analogous
-     * filter source). Used as the snapshot payload when the user clicks
-     * "Save Current Filter."
+     * Current FilterBar state, snapshotted when the save drawer opens.
      */
     currentFilters: Filter[];
     /**
-     * Called when the user picks a preset from the list. The consumer is
-     * responsible for pushing `saved.filters` into their FilterBar (or
-     * equivalent) state. The popover closes immediately after click.
+     * Applies the selected preset externally. The popover closes immediately.
      */
     onApplySavedFilter: (saved: SavedFilter) => void;
     /**
-     * Called when the user submits the "Save Current Filter" drawer. The
-     * payload `filters` is the snapshot of `currentFilters` at the moment the
-     * drawer opened. May return a promise; while pending, the Add button
-     * shows a loading state. Rejecting surfaces an error alert; resolving
-     * surfaces a success alert and closes the drawer.
+     * Persists a named snapshot. A returned promise controls loading; resolving
+     * closes the drawer and rejecting keeps it open with an error.
      */
     onSaveCurrentFilter: (payload: {
         name: string;
         filters: Filter[];
     }) => void | Promise<void>;
     /**
-     * Called when the user submits the drilldown's "Update Filter" action.
-     * Same async / alert semantics as `onSaveCurrentFilter`.
+     * Persists edits to a preset. Resolving returns to the list; rejecting keeps
+     * the edit screen open. Both outcomes show an alert.
      */
     onUpdateSavedFilter: (id: string, update: {
         name: string;
         filters: Filter[];
     }) => void | Promise<void>;
     /**
-     * Called when the user clicks "Delete Filter" in the drilldown. Same
-     * async / alert semantics as `onSaveCurrentFilter`.
+     * Deletes a preset. Both success and failure return to the list with an
+     * outcome alert.
      */
     onDeleteSavedFilter: (id: string) => void | Promise<void>;
     /**
-     * Optional validation for the name field in the save / edit flows. Return
-     * an error string to block submit (Add / Update is disabled); return
-     * `undefined` when valid. The optional `currentId` is set during an edit
-     * flow so the consumer can permit the row's own name in uniqueness
-     * checks.
+     * Validates trimmed names in save and edit flows. Return an error to block
+     * submission; edits include the current preset id.
      */
     validateName?: (name: string, currentId?: string) => string | undefined;
-    /** Optional override for the auto-managed alert text. */
+    /** Configures update, delete, and reorder alerts; error messages take precedence on failure. */
     alertText?: SavedFiltersAlertText;
     /**
-     * Optional id of the preset that is currently applied. When set, the
-     * matching row in the popover renders with a check affordance. The
-     * component does no comparison itself — the consumer is responsible for
-     * tracking which preset (if any) reflects the current filter state, and
-     * for clearing the id when the filters drift (e.g. the user edited a
-     * filter directly).
-     *
-     * Defaults to `undefined`, in which case no row is marked active.
+     * Marks the matching row active. Clear it when current filters no longer
+     * represent that preset.
      */
     activeSavedFilterId?: string;
     /**
-     * Optional trigger label override.
-     * @default "Saved Filters"
+     * Trigger text. Without an override, uses the active preset name when found,
+     * then falls back to `"Saved Filters"`.
      */
     label?: string;
     /**
-     * Optional override for the popover's empty-state content, shown when
-     * `savedFilters` is empty. Defaults to "No saved filters yet."
-     *
-     * - Pass a `string` to keep the default subdued/small `Text` styling — only
-     *   the wording changes.
-     * - Pass any other `ReactNode` (a CTA, an illustration, a styled block) to
-     *   take full control of the empty-state content.
-     *
-     * Separately, when `savedFilters` is empty the "Edit Saved Filters" footer
-     * button is disabled, so this empty-state is the only thing the user sees
-     * in the popover.
+     * Content shown for an empty list. Strings retain default text styling;
+     * other nodes render directly. Defaults to `"No saved filters yet."`.
      */
     emptyState?: ReactNode;
     /**
-     * Called when the user drags a preset to a new position in the "Edit Saved
-     * Filters" drawer. The payload is the full list of preset ids in their new
-     * order; the consumer is responsible for re-sorting their `savedFilters`
-     * array to match.
-     *
-     * Providing this callback opts the Edit drawer into drag-to-reorder UI —
-     * each row picks up a drag handle and keyboard-accessible drop affordance.
-     * Omitting it renders the list as a static stack with no handles.
-     *
-     * May return a promise. A rejection surfaces as a danger alert on the
-     * list view using `alertText.reorderError` (or the thrown Error's message
-     * when present).
+     * Enables reordering and receives the complete id order after a valid drop.
+     * A rejected promise shows a list alert.
      */
     onReorderSavedFilters?: (orderedIds: string[]) => void | Promise<void>;
 };

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

@@ -5,63 +5,66 @@ import { DataTableCacheOptions, DataTableEmptyState, DataTablePaginationConfig,
 export type { DataTableCacheOptions, DataTableRef, DataTableEmptyState, SortedColumn, };
 export type DataTableRowData = object;
 /**
- * Props for the DataTable component
  * @extends LayoutUtilProps
  * @extends ComponentPropsWithoutRef<"div">
  * @extends DataAttributes
  */
 export type DataTableProps<T extends DataTableRowData> = LayoutUtilProps & ComponentPropsWithoutRef<"div"> & DataAttributes & {
     /**
-     * The columns for the table, created with the `createColumnHelper` factory function.
+     * Column defs from `createColumnHelper`. Nested `columns` become grouped
+     * headers.
      */
     columns: ColumnDef<T>[];
     /**
-     * The custom footer content for the table. Will be overridden by the footer content of the columns.
+     * Footer rows that replace column `footerContent` when set.
      */
     customFooter?: CustomTableFooterCellProps[][];
     /**
-     * The data for the table. Must be an array of objects with an `id` property.
+     * Rows to render, or a Promise of rows (loading spacer until it settles).
+     * Each row needs an `id`. Omit or pass `[]` for an empty body.
      */
     data?: TableRow<T>[] | Promise<TableRow<T>[]>;
     /**
-     * The default expanded row ids. Can be "all" to expand all rows, or an array of row ids to expand specific rows.
+     * Uncontrolled initial expansion. `"all"` expands every expandable row.
      */
     defaultExpandedRowIds?: "all" | TableRow<T>["id"][];
     /**
-     * Disables the "expand all" action in the table header.
-     * When true, users can only expand individual rows.
+     * Hides the header expand-all control. Individual rows can still expand.
      * @default false
      */
     disableExpandAll?: boolean;
     /**
-     * The default selected row ids.
+     * Uncontrolled initial selection. Ignored when `isSelectable` is off.
      */
     defaultSelectedRowIds?: TableRow<T>["id"][];
     /**
-     * The default sorted column.
+     * Uncontrolled initial sort. DataTable keeps a single {@link SortedColumn}.
      */
     defaultSortedColumn?: SortedColumn;
     /**
-     * The expanded row ids.
+     * Controlled expansion. `"all"` expands every expandable row. Omit for
+     * uncontrolled (`defaultExpandedRowIds`).
      */
     expandedRowIds?: "all" | TableRow<T>["id"][];
     /**
-     * Disables the "select all" action in the table header.
-     * When true, users can only select individual rows.
+     * Hides the header select-all control. Individual rows can still be selected.
      * @default false
      */
     disableSelectAll?: boolean;
     /**
-     * Whether the table is selectable. Can be a boolean or a function to customize the selection logic.
+     * Adds the selection column. `true` enables every non-read-only row; a
+     * predicate receives the row and returning `false` disables that row's
+     * checkbox. Does not select rows — use `selectedRowIds` /
+     * `defaultSelectedRowIds`.
      * @default false
      */
     isSelectable?: boolean | ((row: T) => boolean);
     /**
-     * Called when the row expansion state changes. Passes the expanded row ids.
+     * Fires with `"all"` or the expanded ids after an expand/collapse.
      */
     onExpandRow?: (expandedRowIds: "all" | TableRow<T>["id"][]) => void;
     /**
-     * Called when the row selection state changes. Passes the selected row ids.
+     * Fires with the selected row ids after a selection change.
      */
     onSelectRow?: (selectedRowIds: TableRow<T>["id"][]) => void;
     /**
@@ -84,13 +87,13 @@ export type DataTableProps<T extends DataTableRowData> = LayoutUtilProps & Compo
      */
     onClickRow?: (rowId: TableRow<T>["id"]) => void;
     /**
-     * Called when the column sorting state changes. Passes the sorted column.
+     * Fires with the active {@link SortedColumn}, or `undefined` when sort is
+     * cleared.
      */
     onSort?: (sortedColumn: SortedColumn | undefined) => void;
     /**
-     * Pagination configuration. When provided, enables pagination and filters data to show only the current page.
-     * When `true`, the default pagination configuration is used.
-     * When `false` or `undefined`, no pagination is applied and all data is shown.
+     * Enables the pager. `true` uses offset defaults (`rowsPerPage: 25`).
+     * `false` or omit shows every row. An object is {@link DataTablePaginationConfig}.
      */
     pagination?: boolean | DataTablePaginationConfig<T>;
     /**
@@ -103,39 +106,32 @@ export type DataTableProps<T extends DataTableRowData> = LayoutUtilProps & Compo
      */
     readOnlyRowIds?: TableRow<T>["id"][];
     /**
-     * The selected row ids.
+     * Controlled selection. Omit for uncontrolled (`defaultSelectedRowIds`).
+     * Ignored when `isSelectable` is off.
      */
     selectedRowIds?: TableRow<T>["id"][];
     /**
-     * The sorted column.
+     * Controlled sort. Omit for uncontrolled (`defaultSortedColumn`).
      */
     sortedColumn?: SortedColumn;
     /**
-     * Configuration for the empty state displayed when the table has no data.
-     * Only shown when data is empty and the table is not loading.
+     * {@link DataTableEmptyState} for an empty current page while not loading.
      */
     emptyState?: DataTableEmptyState;
     /**
-     * Custom content to display when a cell value is empty (null, undefined, or empty string).
-     * Overrides the default em dash for all columns. Individual columns can further override
-     * this with their own `emptyCellContent` property.
+     * Fallback when a cell value is `null`, `undefined`, or `""`. Defaults to
+     * an em dash. A column's `emptyCellContent` wins over this.
      */
     emptyCellContent?: ReactNode;
     /**
-     * Disables row virtualization. By default, tables with 50 or more rows
-     * virtualize their body to keep DOM size bounded; set this to `true` to
-     * render every row in the DOM regardless of count. Intended as an escape
-     * hatch for rollout safety and for flows that need every row mounted
-     * (e.g., find-in-page, certain print or export paths).
-     *
-     * Takes precedence over `forceVirtualization`.
+     * Skips row virtualization at any row count. Default is to virtualize at
+     * 50+ body rows. Wins over `forceVirtualization`.
      * @default false
      */
     disableVirtualization?: boolean;
     /**
-     * Forces row virtualization below the default row-count threshold.
-     *
-     * Ignored when `disableVirtualization` is `true`.
+     * Virtualizes below the 50-row threshold. Ignored when
+     * `disableVirtualization` is `true`.
      * @default false
      */
     forceVirtualization?: boolean;
@@ -155,54 +151,8 @@ export type DataTableProps<T extends DataTableRowData> = LayoutUtilProps & Compo
 };
 declare function DataTableInner<T extends DataTableRowData>(props: DataTableProps<T>, ref: Ref<DataTableRef>): import("react/jsx-runtime").JSX.Element;
 /**
- * Data table component for complex data grid layouts
- *
- * Features:
- * - Built-in focus management for accessibility
- * - Column resizing
- * - Column pinning
- * - Column grouping
- * - Controlled or uncontrolled column sorting
- * - Row selection
- * - Row expansion
- * - Row sub-component
- * - Row sub-rows
- * - Default and Strong backgrounds
- * - Pagination support with configurable items per page
- * - Imperative refresh via ref
- * - Customizable empty state with optional SVG illustration and content
- *
- * @param props - The props for the DataTable component
- * @param props.data - The data for the table. Must be an array of objects with an `id` property.
- * @param props.columns - The columns for the table, created with the `createColumnHelper` factory function.
- * @param props.customFooter - The custom footer content for the table. Will be overridden by the footer content of the columns.
- * @param props.defaultExpandedRowIds - The default expanded row ids.
- * @param props.defaultSelectedRowIds - The default selected row ids.
- * @param props.defaultSortedColumn - The default sorted column.
- * @param props.expandedRowIds - The expanded row ids.
- * @param props.isSelectable - Whether the table is selectable. Can be a boolean or a function to customize the selection logic.
- * @param props.onSelectRow - Called when the row selection state changes. Passes the selected row ids.
- * @param props.onClickRow - Called when a row is clicked or activated via Enter. Passes the clicked row's id. Not triggered by the selection checkbox, editable cells, other interactive cell content, or read-only rows.
- * @param props.onSort - Called when the column sorting state changes. Passes the sorted column.
- * @param props.onExpandRow - Called when the row expansion state changes. Passes the expanded row ids.
- * @param props.pagination - Pagination configuration. When provided, enables pagination and filters data to show only the current page. When undefined, all data is shown and no pagination controls are rendered.
- * @param props.selectedRowIds - The selected row ids.
- * @param props.sortedColumn - The sorted column.
- * @param props.emptyState - Configuration for the empty state displayed when the table has no data.
- * @param props.style - The style of the table container.
- * @param props.rest - The rest of the props for the DataTable component, spread to the div surrounding the table.
- *
- * @example
- * <DataTable
- *   data={tableData}
- *   columns={columns}
- *   pagination={{
- *     itemsPerPage: 25,
- *     defaultPageIndex: 0,
- *     onPageChange: (pageIndex) => console.log('Page changed to:', pageIndex),
- *     showCount: true,
- *   }}
- * />
+ * Sortable, pageable data grid with optional selection, expansion, pinning,
+ * and cell editing. Attach a {@link DataTableRef} to `refresh` or `clearCache`.
  */
 export declare const DataTable: (<T extends DataTableRowData>(props: DataTableProps<T> & {
     ref?: Ref<DataTableRef>;

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

@@ -1,41 +1,34 @@
 import { ComponentPropsWithoutRef } from 'react';
 import { Table as TanstackTable } from '@tanstack/react-table';
 import { DataTableVirtualizer } from './useDataTableVirtualizer';
-/**
- * Props for the DataTableBody component
- * @property {TanstackTable<T>} table - The table instance from @tanstack/react-table to render
- * @property {boolean} hasSubRows - Whether the table has sub rows
- * @property {DataTableVirtualizer | undefined} virtualizer - Optional virtualizer instance; when provided the body switches to absolute-position row layout
- * @property {(row: T) => unknown} [getRowVersion] - Optional consumer-provided function whose return value signals whether a row has changed. When supplied, rows are memoized; when omitted, every row re-renders with the parent.
- * @extends {ComponentPropsWithoutRef<"div">}
- */
 export type DataTableBodyProps<T> = {
-    /**
-     * The table instance from @tanstack/react-table to render
-     */
+    /** TanStack instance: row model, header-group count for row indices, column order. */
     table: TanstackTable<T>;
     /**
-     * Whether the table has sub rows
+     * Table-wide grouping flag. Forwarded as `tableHasSubRows` so rows can
+     * expose `aria-expanded` / `aria-level` even when they cannot expand.
      */
     hasSubRows: boolean;
     /**
-     * Optional virtualizer instance. When provided the body renders only the
-     * visible virtual items in an absolutely-positioned layout instead of
-     * rendering all rows in the parent CSS grid flow.
+     * When set, only visible virtual items render in an absolutely positioned
+     * stack. When omitted, every row stays in the parent CSS grid.
      */
     virtualizer: DataTableVirtualizer | undefined;
     /**
-     * Optional consumer-provided function that returns a value expressing
-     * "this row has changed." When supplied, each row is memoized and only
-     * re-renders when the returned value differs from the previous render
-     * (or when table-managed row state like selection or expansion changes).
-     * When omitted, every row re-renders whenever the parent re-renders.
+     * Opt-in memo key forwarded to each row. When omitted, rows re-render with
+     * this body. When set, skip re-render unless this value or table-managed
+     * row UI state changes.
      */
     getRowVersion?: (row: T) => unknown;
     /**
-     * Map of read-only row ids keyed by id. Read-only rows gray their plain
-     * text content and render disabled, read-only selection checkboxes.
+     * Read-only rows keyed by id. Forwarded as `isReadOnly` so those rows gray
+     * plain text and skip row-click. Selection checkbox disabling is gated
+     * separately via `enableRowSelection`.
      */
     readOnlyRowMap: Record<string, boolean>;
 } & ComponentPropsWithoutRef<"div">;
+/**
+ * Data-table body. Maps TanStack rows through `TableBody` to
+ * `DataTableBodyRow`, forwarding grouping, read-only, and memo keys.
+ */
 export declare function DataTableBody<T>(props: DataTableBodyProps<T>): import("react/jsx-runtime").JSX.Element;