import { An as insertExtrasBeforeRows, B as FilterRuntime, Cn as extraCoveredTableSlots, Dn as extraUncoveredColSpans, En as extraRowsForSection, Fn as resolveRowHeight, Gn as QuerySupport, In as resolveRowStyle, L as FilterDef, Mn as RowHeight, Nn as RowStyle, On as inflateBodyCellRowSpans, Rn as rowStyleSignature, Sn as extraCountBeforeRowIds, Z as FilterTypeRegistry, _ as RowAction, _n as EXTRA_OVER_SPAN_STYLE, bn as ExtraRow, cn as GroupAggregatesFn, d as Direction, fn as GroupedFlatEntry, gn as EXTRA_OVER_SPAN_ROW_STYLE, jn as isExtraEntry, kn as insertExtraRows, n as BulkAction, o as ColumnDef, r as BulkActionContext, rn as TableSource, rr as EditableColumnLike, v as SortByOption, vn as EXTRA_ROW_PARTS, w as FacetMap, wn as extraHostFillStyle, x as TableLabels, yn as ExtraEntry } from "./types-Cqk1_BXq.js"; import { $i as UseDataTableResult, $o as FindInTableState, $t as FilterTriggerToggle, As as FilterHeaderSelectProps, Ba as pinnedRowCellStyle, Bi as SidePanelCloseProps, Bl as resolveDisabledReason, Ca as rowReorderSignature, Ci as fillSlot, Cl as useCommandPalette, Cs as FilterHeaderControlChromeProps, Da as RowActionsRenderer, Ds as FilterHeaderRangeProps, Es as FilterHeaderOption, Fn as BaseDataTableProps, Fo as TreeEntry, Fs as ExportStatus, Gc as ColumnDragRowAttrs, Gi as SidePanelSlots, Gs as editorValidationProps, Ha as pinnedRowSticky, Hc as ColumnResizeHandleProps, Hi as SidePanelFrameProps, Hl as Command, Hs as EditableCellSlots, Ii as FullscreenState, Il as ContextMenuPoint, Is as useExportHandler, Jc as ColumnReorderKeyProps, Js as EditableCellEditing, Kc as ColumnDragState, Ki as SidePanelTabProps, Kl as ContextMenuItem, Ks as multiDraftFromSelect, La as PINNED_BOTTOM_PART, Li as useFullscreen, Ll as ConfirmHandler, Ln as ToolbarSlots, Ls as EditableCellActivateProps, Ma as GroupCollapseState, Nc as DEFAULT_CARD_SIZE_PX, Ol as SelectionState, Os as FilterHeaderRowProps, Pa as GroupByInput, Pl as bulkActionErrorMessage, Ps as ExportHandlerState, Qs as rowIsDirty, Ra as PINNED_TOP_PART, Ri as SidePanelChrome, Rs as EditableCellButtonProps, Sa as rowReorderDropStyle, Sl as TableCommandPalette, Ss as FilterHeaderControlChrome, Ta as RowActionsLayout, Tc as BatchEditingState, Ti as DataModeProps, Ts as FilterHeaderMultiProps, Ua as pinnedRowStickyStyle, Ui as SidePanelLayout, Uo as SelectionStats, Us as commitBooleanDraft, Va as pinnedRowPart, Wa as useOffsetHeight, Wc as COLUMN_DND_MIME, Wi as SidePanelLayoutProps, Ws as editorBusyProps, Xi as SortButtonElementProps, Xs as focusEditorOnMount, Ya as RowPinSide, Yc as ColumnRowDragProps, Za as RowPinningState, Zs as rowEditingSignature, Zt as BulkBarChromeProps, _l as unpinAllColumns, al as ColumnMenuRow, an as undoRedoToolbar, bi as nestedTableDetail, bl as useTableContextMenu, bs as FilterHeaderChromeProps, cl as columnMenuActions, co as rowSourceIndex, da as TreeExpansionState, dc as RowEditingState, dl as filterColumnMenuRows, en as TableBodyRegion, fl as hideAllColumns, fo as ResizableVirtualizer, ga as ROW_DND_MIME, gl as showAllColumns, go as FeatureNoticeKind, ha as REORDER_COLUMN_WIDTH, hl as resetColumnLayout, ho as FeatureNotice, ii as SavedView, il as ColumnMenuLabels, in as printToolbar, ja as MobileCardRenderer, js as FilterHeaderSlots, ks as FilterHeaderSearchProps, la as paginationItems, lo as useKeyedVirtualization, ml as pinActionLabel, mo as useRowPairMeasurer, nl as ColumnMenuActionContext, nn as ToolbarChromeProps, oa as PaginationItem, ol as PinnedSide, oo as VirtualTableRow, pa as RowExpansionState, pl as nextPinSide, po as RowPairMeasurer, qc as ColumnDropProps, qi as CellElementProps, ql as ContextMenuTarget, qo as GridFocusState, rl as ColumnMenuChromeProps, rn as ViewControlsToolbar, ro as KeyedVirtualization, sa as PaginationSlot, so as resolveVirtualRows, ti as SearchInputState, tl as ColumnMenuAction, tn as TableChrome, to as rowPinSignature, ua as paginationSlots, un as viewControlsToolbar, va as RowReorderLabels, vi as NestedTableParent, vn as EditHistoryState, wi as tableErrorState, ws as FilterHeaderControlProps, xs as FilterHeaderClassNames, ya as RowReorderState, yi as nestedTableDefaults, yl as TableContextMenu, ys as FilterHeaderChrome, za as orderedCardEntries, zc as pinnedColumnWidth, zi as SidePanelChromeProps, zs as EditableCellEditorCtrl } from "./index-Ab91GGk9.js"; import { $ as groupedHeaderCellStyle, D as PinSide, E as PinOffset, F as ColumnGroupRecord, G as COLUMN_GROUP_STUB_WIDTH, H as COLUMN_GROUP_ID_SEP, I as ColumnInput, J as columnGroupHeaderCaption, K as HeaderGroupCell, O as PinnedCellStyle, P as ColumnGroupDef, Q as groupedHeaderAlign, R as applyCollapsedColumnGroups, T as PinLeads, U as COLUMN_GROUP_RENDER_PREFIX, W as COLUMN_GROUP_STUB_PREFIX, X as columnGroupPath, Y as columnGroupId, Z as columnGroupStubStyle, at as isColumnGroupRenderKey, ct as toggleCollapsedColumnGroup, d as BodyCell, et as groupedHeaderChildRule, f as CellSpanAppearance, g as bodyCellsHaveRowSpan, it as htmlGroupedHeaderPlan, m as GetCellSpan, nt as headerGroupRow, ot as isColumnGroupStubKey, q as HtmlGroupedHeaderCell, rt as headerGroupRows, st as isColumnGroupSummaryKey, tt as groupedHeaderLabelStyle, v as cellSpanMark, x as rowSpanSignature, y as cellsForRow, z as flattenColumnTree } from "./exportWriter-VdWUamzf.js"; import { n as AggregateName } from "./aggregate-C1nNljQr.js"; import { h as PivotConfig, i as PivotZone, r as PivotField } from "./pivotConfigModel-B6dLmZtw.js"; import { a as useResolvedAdapter, t as UrlStateAdapter } from "./adapter-BD3RX3cl.js"; import { CSSProperties, DependencyList, KeyboardEvent, MouseEvent, ReactElement, ReactNode, RefCallback, RefObject } from "react"; //#region src/a11y/LiveRegion.d.ts /** Props for {@link LiveRegion}. */ interface LiveRegionProps { /** What to announce. Empty until there is something. */ children: string; /** `data-adapttable-part`, so a test or a style can find this one. */ part: string; } /** * Announce a message politely, showing nothing. * * @param props - See {@link LiveRegionProps}. */ declare function LiveRegion({ children, part }: Readonly): ReactElement; //#endregion //#region src/actions/CommandPaletteChrome.d.ts /** Props an adapter's palette surface receives. */ interface CommandPaletteSurfaceProps { /** Accessible name for the dialog. */ readonly label: string; /** Close it — bind to the kit's own dismiss channel. */ readonly onClose: () => void; readonly children: ReactNode; readonly className?: string; } /** Props an adapter's search input receives. */ interface CommandPaletteInputProps { /** Spread onto the input: value, handlers, and the combobox wiring. */ readonly inputProps: { readonly value: string; readonly onChange: (next: string) => void; readonly onKeyDown: (event: KeyboardEvent) => void; readonly ref: (element: HTMLInputElement | null) => void; readonly role: "combobox"; readonly "aria-expanded": true; readonly "aria-controls": string; readonly "aria-activedescendant": string | undefined; readonly "aria-label": string; readonly placeholder: string; readonly "data-adapttable-part": "command-input"; }; } /** Props an adapter's command row receives. */ interface CommandPaletteItemProps { readonly command: Command; readonly active: boolean; /** Spread onto the row: the option role, its id, and selection. */ readonly itemProps: { readonly id: string; readonly role: "option"; readonly "aria-selected": boolean; readonly "aria-disabled": boolean | undefined; readonly "data-adapttable-part": "command-item"; readonly onClick: () => void; readonly onMouseEnter: () => void; }; } /** Adapter-owned rendering for {@link CommandPaletteChrome}. */ interface CommandPaletteSlots { /** The modal surface. */ readonly Surface: (props: CommandPaletteSurfaceProps) => ReactNode; /** The search box. */ readonly Input: (props: CommandPaletteInputProps) => ReactNode; /** One command. */ readonly Item: (props: CommandPaletteItemProps) => ReactNode; /** Shown when nothing matches. */ readonly Empty: (props: { readonly message: string; }) => ReactNode; } /** What the palette needs to render. */ interface CommandPaletteChromeProps { /** Every command available right now. */ commands: readonly Command[]; /** Whether it is showing. */ open: boolean; /** Close it. */ onClose: () => void; /** Labels; falls back to the built-in English. */ labels?: TableLabels; /** A kit's own class for the surface. */ className?: string; /** Adapter-owned visible components. */ slots: CommandPaletteSlots; } /** * Renders the command palette, or nothing when it is closed. * * @param props - The commands, whether it is open, and the kit's slots. * @returns The palette. */ declare function CommandPaletteChrome(props: Readonly): import("react").JSX.Element | null; //#endregion //#region src/actions/ContextMenuChrome.d.ts /** Props an adapter's menu surface receives. */ interface ContextMenuSurfaceProps { /** Where the menu was opened, in viewport coordinates. */ readonly at: ContextMenuPoint; /** * A zero-size element sitting at exactly that point. * * Every kit's menu anchors to an ELEMENT, not to coordinates — that is * how it decides which way to flip near an edge and where to portal to. * A right-click has coordinates and no element, so core puts one there. * Anchor the kit's menu to this and its positioning, flipping and * collision handling all work the way that kit's users expect. */ readonly anchorRef: RefObject; /** The accessible name for the menu. */ readonly label: string; /** Close it — bind to the kit's own dismiss channel. */ readonly onClose: () => void; /** Where the kit must portal while fullscreen; `undefined` otherwise. */ readonly container?: HTMLElement; /** The entries, already rendered through the Item and Separator slots. */ readonly children: ReactNode; readonly className?: string; } /** Props an adapter's menu entry receives. */ interface ContextMenuItemProps { readonly item: ContextMenuItem; /** * Bind this rather than `item.onSelect`: it closes the menu first, which * an entry that opens a dialog or moves focus depends on. */ readonly onSelect: () => void; } /** Adapter-owned rendering for {@link ContextMenuChrome}. */ interface ContextMenuSlots { /** The kit's menu, positioned at the point it was opened from. */ readonly Surface: (props: ContextMenuSurfaceProps) => ReactNode; /** One entry. */ readonly Item: (props: ContextMenuItemProps) => ReactNode; /** The divider between groups of entries. */ readonly Separator: () => ReactNode; } /** What the context menu needs to render. */ interface ContextMenuChromeProps { /** The entries. Nothing renders when this is empty. */ items: readonly ContextMenuItem[]; /** Where it was opened, or `null` when it is closed. */ at: ContextMenuPoint | null; /** Close it, putting focus back where it came from. */ onClose: () => void; /** Labels; falls back to the built-in English. */ labels?: TableLabels; /** A kit's own class for the menu. */ className?: string; /** * Where to portal while the table is fullscreen. * * The Fullscreen API hides everything outside the promoted element, so a * menu portalled to `document.body` is mounted, focused and invisible. * `shell.fullscreen.container` is that element while it is on. */ container?: HTMLElement; /** Adapter-owned visible components. */ slots: ContextMenuSlots; } /** * Renders the open context menu, or nothing. * * @param props - The entries, where they were opened, and the kit's slots. * @returns The menu. */ declare function ContextMenuChrome(props: Readonly): import("react").JSX.Element | null; //#endregion //#region src/actions/contextMenuRegion.d.ts /** The attribute a row carries so its menu knows which row it is. */ declare const ROW_ID_ATTRIBUTE = "data-row-id"; /** What {@link resolveContextTarget} found. */ interface ResolvedContextTarget { target: ContextMenuTarget; /** The element the menu was opened from, for focus on the way back. */ element: HTMLElement; } /** * Work out which header, row or cell an event happened in. * * @param from - The element the event started at. * @param rowFor - Turns a row id back into the row, since the DOM only * carries the id. Returning `undefined` means the row is no longer * rendered, and there is nothing to open a menu for. * @returns The target and the element to restore focus to, or `null` when * the event happened somewhere with no menu of its own. */ declare function resolveContextTarget(from: Element, rowFor: (rowId: string) => TRow | undefined): ResolvedContextTarget | null; //#endregion //#region src/actions/useBulkBarState.d.ts /** Options for {@link useBulkBarState}. */ interface UseBulkBarStateOptions { /** Current selection state. */ selection: SelectionState; /** Total rows in the filtered set (drives the "select all matching" banner). */ total: number; /** Confirmation handler for actions that declare a `confirm` block. */ confirm: ConfirmHandler; /** Resolved labels. */ labels: Required; } /** The derived bulk-bar state every adapter renders from. */ interface BulkBarState { /** Number of rows currently selected. */ selectedCount: number; /** Selected ids as a fresh array (safe to pass to `run`). */ ids: string[]; /** Key of the action currently running, or `null`. */ pending: string | null; /** * Message of the last failed run, or `null`. The selection is KEPT on * failure (so the user can retry); adapters render this in the bar, * ideally in a live region. */ errorMessage: string | null; /** Run a bulk action against `ids` (and `scope` when "all matching" is on). */ run: (action: BulkAction, ids: string[], context?: BulkActionContext) => void; /** Clear the selection. */ clear: () => void; /** Whether the "select all N matching" banner should show. */ expandable: boolean; /** Bulk-action scope: the whole matching set when active, else `undefined`. */ scope: BulkActionContext | undefined; /** The banner's text, action label, and click handler for the current state. */ banner: { text: string; action: string; onClick: () => void; }; } /** * Derive the kit-independent state a bulk-action toolbar renders from: * the selected ids, the in-flight action, the run/clear handlers, and the * two-state "select all matching" banner. Extracting this keeps the logic in * one place so adapter `BulkBar` components only differ in their kit JSX. * * Call unconditionally (it uses a hook); do the `selectedCount === 0` early * return in the adapter AFTER calling this. */ declare function useBulkBarState({ selection, total, confirm, labels }: Readonly): BulkBarState; //#endregion //#region src/columns/ColumnGroupToggle.d.ts /** Props for an adapter {@link ColumnGroupToggle} — no slots on the public API. */ interface ColumnGroupToggleProps { cell: HeaderGroupCell; labels: Required; onToggle: (id: string) => void; className?: string; } /** Kit button the column-group chrome calls. */ interface ColumnGroupToggleButtonProps { readonly label: string; readonly expanded: boolean; readonly className?: string; readonly onClick: () => void; } /** Adapter-supplied controls for {@link ColumnGroupToggleChrome}. */ interface ColumnGroupToggleSlots { readonly Button: (props: ColumnGroupToggleButtonProps) => ReactNode; } /** Props for {@link ColumnGroupToggleChrome}. */ interface ColumnGroupToggleChromeProps extends ColumnGroupToggleProps { readonly slots: ColumnGroupToggleSlots; } /** Collapse/expand control for one column-group header cell. */ declare function ColumnGroupToggleChrome({ cell, labels, onToggle, className, slots }: Readonly): ReactElement; //#endregion //#region src/columns/columnSizing.d.ts /** What the sizing needs to know about the table as a whole. */ interface ColumnSizingOptions { /** The columns as rendered. */ columns: readonly ColumnDef[]; /** Whether the table fits its container rather than overflowing it. */ fitColumns?: boolean; /** User widths from the layout state, which always win. */ widths?: Readonly>; } /** * The share of leftover space each flexible column takes. * * A column with a width — declared or dragged — is not flexible: the user or * the author already answered the question for it. Everything else divides * what remains, weighted by `flex`, which defaults to 1 in fitting mode so a * table of plain columns simply spreads. * * @typeParam TRow - The row type. * @param options - See {@link ColumnSizingOptions}. * @returns Total flex weight, and each flexible column's percentage. */ declare function columnFlexShares(options: ColumnSizingOptions): Readonly>; /** * The style one column's cells carry: its width, and the bounds it keeps. * * The user's dragged width wins over everything — they said what they wanted * — then the column's own `width`, then its share of the leftover space. * * @typeParam TRow - The row type. * @param column - The column being sized. * @param shares - Percentages from {@link columnFlexShares}. * @param userWidth - The width from the layout state, when the user set one. * @returns The style, or `undefined` when the column says nothing about size. */ declare function columnSizeStyle(column: ColumnDef, shares?: Readonly>, userWidth?: number): CSSProperties | undefined; /** * The style the `` itself carries when it fits its container. * * `table-layout: fixed` is what makes percentage widths mean anything: without * it the browser sizes columns from their content and the percentages are a * suggestion it may ignore. * * @param fitColumns - Whether the table fits its container. * @returns The style, or `undefined` when it overflows as usual. */ declare function fittedTableStyle(fitColumns?: boolean): CSSProperties | undefined; //#endregion //#region src/columns/icons.d.ts /** * Shared column-menu glyphs (currentColor, no icon-lib dependency) so every * adapter's column popover looks identical: a drag grip, an eye visibility * toggle, and a pin. */ /** Six-dot drag grip. */ declare function GripIcon(): ReactElement; /** Eye (visible) / eye with slash (hidden) toggle glyph. */ declare function EyeIcon({ off }: Readonly<{ off?: boolean; }>): ReactElement; /** Pin glyph. */ declare function PinIcon(): ReactElement; //#endregion //#region src/display.d.ts /** * Kit-independent display helpers shared by every adapter's table chrome — * logical alignment, the sort-indicator glyph, sticky pinned-cell styles, and * the row-memo guard. Centralising them keeps the adapters' render files from * duplicating the same pure logic. */ /** * Pinned data-cell sticky style with an opaque `background` so scrolled columns * don't bleed through the pinned ones. Adapters pass their kit's surface * background token as `bg`; a raw `style` object keeps the pixel insets the * core layout computes from being mangled by a kit's prop-to-spacing scale. */ declare function pinnedDataCellStyle(pin: PinOffset | undefined, z: number, leads: PinLeads, bg: string): CSSProperties | undefined; /** * Sticky style for a non-data edge cell (expand chevron, selection, actions): * flush to its side when a data column on that side is pinned. `shift` insets a * left-edge cell past the leading expansion column so the chevron and the * selection checkbox pin side by side. */ declare function pinnedEdgeCellStyle(side: PinSide, active: boolean, z: number, bg: string, shift?: number): CSSProperties | undefined; /** * The row-prop keys (other than the kit's own accent token) that change a * desktop row's visuals — the memo guard re-renders a row only when one of * these differs. Each adapter appends its theming key (`accentColor`) * to this shared base. */ declare const SHARED_DESKTOP_ROW_KEYS: readonly ["row", "id", "index", "selected", "expanded", "size", "dir", "columns", "columnWidths", "pinSignature", "className", "labels", "hasSelection", "expandable", "showActions", "showReorder", "reorderSignature", "rowPinSignature", "spanSignature", "hasRowClick", "columnSpan", "gridFocus", "treeEntry", "treeColumnKey", "rowActionsLayout", "renderRowActions", "cellSpanAppearance"]; /** Shallow-equal two objects across a fixed key set (the row-memo guard). */ declare function shallowEqualByKeys(keys: readonly (keyof T)[], prev: Readonly, next: Readonly): boolean; /** * Spreadsheet merge paint: centered content and one fill across the span. * `"plain"` (or a 1×1 cell) returns nothing. Adapters pass this as the base * to {@link cellHighlightStyle} so a selection or find hit still wins the * background. Override the fill with `--adapttable-cell-span-fill`. * * @param colSpan - Horizontal span on the origin cell. * @param rowSpan - Vertical span on the origin cell. * @param appearance - `"merged"` (default) or `"plain"`. * @param fill - `"off"` keeps centering without a wash (unstyled selection * classes need the background free). */ declare function mergedCellStyle(colSpan: number, rowSpan: number, appearance?: CellSpanAppearance, fill?: "on" | "off"): CSSProperties | undefined; /** * Map a column's logical alignment onto the `"start" | "center" | "end"` * value every kit's cell/justify prop accepts. `undefined` defaults to start. */ declare function logicalAlign(align: ColumnDef["align"]): "start" | "center" | "end"; /** * Header sort indicator text derived from a cell's computed sort state * (`aria-sort` value): `↑` ascending, `↓` descending, `↕` unsorted. Kits that * render the bare arrows as emoji (e.g. Radix Themes' font) append a * text-presentation selector on top of this base string. */ declare function sortArrow(sort: unknown): string; /** * Is this cell inside the selected range? * * Core marks a selected cell with `data-cell-selected` through * `gridFocus.getCellProps`, but it cannot colour it: a selection has to look * like the kit it lives in, and a hard-coded blue would be wrong in seven of * eight. So core answers the question and each adapter answers it with its own * theme token — the same division as {@link pinnedDataCellStyle}, which takes * the kit's surface colour as an argument. * * Without this the range was invisible: the attribute reached the DOM in 2.2.0 * and no adapter styled it, so a user extending a selection saw nothing move. * * @param props - The props from `getCellProps` / `getCellPropsAt`, or nothing. * @returns Whether the cell should render as selected. */ declare function isSelectedCell(props: Readonly> | undefined): boolean; /** * Is this cell one the find bar matched? * * @param props - The props from `getCellProps` / `getCellPropsAt`, or nothing. * @returns Whether the cell contains a match. */ declare function isMatchedCell(props: Readonly> | undefined): boolean; /** * Is this the match the find walk is currently on? * * @param props - The props from `getCellProps` / `getCellPropsAt`, or nothing. * @returns Whether the cell is the current match. */ declare function isCurrentMatchCell(props: Readonly> | undefined): boolean; /** * A cell's background, given everything that might want to colour it. * * A find highlight is the one cell colour that is NOT a kit's to choose. It is * a browser convention — the same amber every browser paints Ctrl+F hits in — * and a table that answered it in eight different accent colours would be * harder to read, not more native. So the kit supplies its selection fill and * core supplies the match fill, both overridable through * `--adapttable-find-match` / `--adapttable-find-match-current`. * * The current match wins over other matches, which win over the selection — * the find walk moves the selection with it, so without that order the cell * you were sent to would be the one cell not marked as a hit. * * @param props - The props from `getCellProps` / `getCellPropsAt`, or nothing. * @param base - The kit's own cell style (pinning, alignment). * @param selected - The kit's fill for a selected cell. * @returns The merged style, or `base` when nothing highlights this cell. */ declare function cellHighlightStyle(props: Readonly> | undefined, base: CSSProperties | undefined, selected: CSSProperties): CSSProperties | undefined; /** The three rows a grouped body renders, all through one component. */ type GroupRowKind = "group" | "groupFooter" | "groupMore"; /** * The `data-adapttable-part` names for one of those rows. * * One place decides them, because a header, its footer and its "show more" row * are the same component in every kit — and three nested ternaries per kit is * how those names drift apart. * * @param kind - Which of the three the entry is. * @returns The part names for its row, cell, card and label. */ declare function groupRowParts(kind: GroupRowKind): { row: string; cell: string; card: string; label: string; }; /** * How far a nested group header sits in from the one above it. * * Logical padding, so a nested group indents from the right in Arabic and * Hebrew without a second rule. One value in core rather than eight in the * adapters: nesting that steps by 1.5rem in one kit and 8px in another reads * as a bug in whichever the user sees second. * * @param level - The header's depth, from zero. * @returns The style for the header's label cell. */ declare function groupIndentStyle(level: number): CSSProperties; /** * The caption a mobile card shows beside a cell's value. * * A card is a list of label/value pairs, not a grid with a header row, so each * value has to carry its own caption. `mobileLabel` sets it; an **empty string** * deliberately removes it, which is how a card shows a bare value (an avatar, a * title line) with no caption above it. Without one, a string `header` is the * caption and the column's key is the last resort. * * Every adapter's card layout resolves this the same way, and it lives here * because seven of them once each had their own copy under two different names. * * @typeParam TRow - The row type. * @param column - The column being rendered in a card. * @returns The caption, or `undefined` when the card should show none. */ declare function resolveMobileLabel(column: ColumnDef): string | undefined; //#endregion //#region src/editing/RowEditGate.d.ts /** Props for {@link RowEditCell}. */ interface RowEditCellProps { /** The row-editing state from the chrome. */ rowEditing: RowEditingState; /** The column this cell belongs to. */ column: EditableColumnLike; /** The cell's display content, for a column that is not editable. */ display: ReactElement | string | number | null; /** Accessible name for the editor (`labels.editCell`). */ editLabel: string; /** * Whether this is the first editable column of the row, and so the field the * table hands focus to when the row opens. Every field calling focus on mount * would leave the reader at the last column of the row they just opened. * * Not the DOM's `autoFocus`: focus moves because a reader asked to edit this * row, which is the case the accessibility guidance carves out. */ takesFocus: boolean; /** * Render the kit's own editor from a controller — the same callback shape the * cell gate uses, so a kit writes one editor and both modes use it. */ renderEditor: (ctrl: EditableCellEditorCtrl) => ReactElement; } /** * One cell of a row being edited: the kit's editor bound to the row's draft, or * the plain display when the column is not editable. * * @typeParam TRow - The row type. * @param props - See {@link RowEditCellProps}. * @returns The editor, or the display content. */ declare function RowEditCell({ rowEditing, column, display, editLabel, takesFocus, renderEditor }: Readonly>): ReactElement; /** Props for {@link rowEditControls}. */ interface RowEditControlsOptions { /** The row-editing state from the chrome. */ rowEditing: RowEditingState; /** The row this control set belongs to. */ row: TRow; /** Its stable id. */ rowId: string; /** Labels; falls back to the built-in English. */ labels?: TableLabels; } /** What a kit needs to render the row's edit / save / cancel controls. */ interface RowEditControls { /** Whether this row is the one being edited. */ editing: boolean; /** Open this row for editing. */ begin: () => void; /** Hand the host everything that changed. */ save: () => void; /** Throw the drafts away. */ cancel: () => void; /** Accessible name for the control that opens the row. */ editLabel: string; /** Accessible name for save. */ saveLabel: string; /** Accessible name for cancel. */ cancelLabel: string; /** Whether anything actually changed — a save with nothing to save is inert. */ dirty: boolean; } /** * The row-mode controls, resolved. * * A helper rather than a component because each kit renders its own buttons — * what is shared is which ones exist, what they are called, and what they do. * * @typeParam TRow - The row type. * @param options - See {@link RowEditControlsOptions}. * @returns The controls to render. */ declare function rowEditControls({ rowEditing, row, rowId, labels }: Readonly>): RowEditControls; /** Props for an adapter {@link RowEditActions} — no slots on the public API. */ interface RowEditActionsProps extends RowEditControlsOptions { /** Class for the control group. */ className?: string; /** Class for each button. */ buttonClassName?: string; } /** Kit button the row-edit chrome calls. */ interface RowEditButtonProps { readonly label: string; readonly part: string; readonly className?: string; readonly onClick: (event: { stopPropagation: () => void; }) => void; } /** Adapter-supplied controls for {@link RowEditActionsChrome}. */ interface RowEditActionsSlots { readonly Button: (props: RowEditButtonProps) => ReactNode; } /** Props for {@link RowEditActionsChrome}. */ interface RowEditActionsChromeProps extends RowEditActionsProps { readonly slots: RowEditActionsSlots; } /** * The row's edit / save / cancel controls. * * Layout and the shared {@link rowEditControls} contract — adapters pass the * buttons the end user clicks. A kit with a strong opinion about its buttons * can still use {@link rowEditControls} directly instead. * * @typeParam TRow - The row type. * @param props - See {@link RowEditActionsChromeProps}. * @returns The controls for this row. */ declare function RowEditActionsChrome({ className, buttonClassName, slots, ...options }: Readonly>): ReactElement; /** Props for {@link BatchEditCell}. */ interface BatchEditCellProps { /** The batch state from the chrome. */ batch: BatchEditingState; /** The row this cell belongs to. */ row: TRow; /** Its stable id. */ rowId: string; /** The column this cell belongs to. */ column: EditableColumnLike; /** The cell's display content, for a column that is not editable. */ display: ReactElement | string | number | null; /** Accessible name for the editor (`labels.editCell`). */ editLabel: string; /** Render the kit's own editor from a controller. */ renderEditor: (ctrl: EditableCellEditorCtrl) => ReactElement; } /** * One cell while a batch is being edited: always a field, never an activate * control. * * Batch mode's premise is that the reader is walking a list correcting values, * so making them open each cell first would be the friction the mode exists to * remove. A changed cell carries `data-changed`, which is how the reader finds * their way back to what they touched. * * @typeParam TRow - The row type. * @param props - See {@link BatchEditCellProps}. * @returns The field, or the display content. */ declare function BatchEditCell({ batch, row, rowId, column, display, editLabel, renderEditor }: Readonly>): ReactElement; /** Props for an adapter {@link BatchEditBar} — no slots on the public API. */ interface BatchEditBarProps { /** The batch state from the chrome. */ batch: BatchEditingState; /** Labels; falls back to the built-in English. */ labels?: TableLabels; /** Class for the bar. */ className?: string; /** Class for each button. */ buttonClassName?: string; } /** Kit button the batch-edit bar calls. */ interface BatchEditButtonProps { readonly label: string; readonly part: string; readonly className?: string; readonly onClick: () => void; } /** Adapter-supplied controls for {@link BatchEditBarChrome}. */ interface BatchEditBarSlots { readonly Button: (props: BatchEditButtonProps) => ReactNode; } /** Props for {@link BatchEditBarChrome}. */ interface BatchEditBarChromeProps extends BatchEditBarProps { readonly slots: BatchEditBarSlots; } /** * The bar that ends a batch: how many rows are waiting, save all, cancel all. * * Rendered only while something is pending — a bar that is always there says * the table is in a mode, when what matters is that there are unsaved changes. * * @typeParam TRow - The row type. * @param props - See {@link BatchEditBarChromeProps}. * @returns The bar, or nothing. */ declare function BatchEditBarChrome({ batch, labels, className, buttonClassName, slots }: Readonly>): ReactElement | null; //#endregion //#region src/export/ExportAnnouncer.d.ts /** Props for {@link ExportAnnouncer}. */ interface ExportAnnouncerProps { /** `exportAnnouncement` from `useExportHandler`. Empty until an export ends. */ announcement: string; } /** * Renders the export's outcome announcement. Always mounted beside the button, * because a region that appears together with its message is missed. * * @param props - See {@link ExportAnnouncerProps}. */ declare function ExportAnnouncer({ announcement }: Readonly): ReactElement; //#endregion //#region src/export/exportLabel.d.ts /** * The caption for an export button producing `format`. * * @param labels - Resolved table labels. * @param format - The writer's extension, e.g. `"csv"` or `"xlsx"`. * @returns The button's text. */ declare function exportButtonLabel(labels: TableLabels | undefined, format: string): string; //#endregion //#region src/filters/ChecklistChrome.d.ts /** Class hooks the unstyled adapter maps onto `DataTableClassNames`. */ interface ChecklistClassNames { filterChecklist?: string; filterChecklistSearch?: string; filterChecklistActions?: string; filterChecklistList?: string; filterChecklistCount?: string; filterField?: string; filterLabel?: string; filterInput?: string; filterCheckboxGroup?: string; filterCheckbox?: string; } /** Props for an adapter {@link ChecklistFilter} — no slots on the public API. */ interface ChecklistFilterProps { readonly def: FilterDef; readonly source: Pick, "allFilteredRows" | "extra" | "setExtra" | "facets">; readonly labels?: TableLabels; readonly classNames?: ChecklistClassNames; } /** Kit search field the checklist layout calls. */ interface ChecklistSearchProps { readonly label: string; readonly value: string; readonly className?: string; readonly onChange: (value: string) => void; } /** Kit button the checklist layout calls. */ interface ChecklistButtonProps { readonly label: string; readonly onClick: () => void; } /** Kit checkbox row the checklist layout calls. */ interface ChecklistCheckboxProps { readonly label: string; readonly count: string; readonly checked: boolean; readonly className?: string; readonly countClassName?: string; readonly onChange: (checked: boolean) => void; } /** Adapter-supplied controls for {@link ChecklistChrome}. */ interface ChecklistSlots { readonly Search: (props: ChecklistSearchProps) => ReactNode; readonly Button: (props: ChecklistButtonProps) => ReactNode; readonly Checkbox: (props: ChecklistCheckboxProps) => ReactNode; } /** Props for {@link ChecklistChrome}. */ interface ChecklistChromeProps extends ChecklistFilterProps { readonly slots: ChecklistSlots; } /** * Distinct-values checklist layout. Returns `null` when the source has no * `allFilteredRows` and no facets — a server page must declare facets * before this widget can count a set it does not hold. */ declare function ChecklistChrome({ def, source, labels: labelOverrides, classNames, slots }: Readonly>): import("react").JSX.Element | null; //#endregion //#region src/filters/FilterTreeChrome.d.ts /** Class hooks the unstyled adapter maps onto `DataTableClassNames`. */ interface FilterTreeClassNames { filterTree?: string; filterTreeGroup?: string; filterTreeCondition?: string; filterTreeActions?: string; filterTreeRemove?: string; filterTreeSummary?: string; filtersForm?: string; filterField?: string; filterLabel?: string; filterInput?: string; filterSelect?: string; filterOperator?: string; } /** Props for an adapter {@link FilterTreeBuilder} — no slots on the public API. */ interface FilterTreeBuilderProps { readonly defs: readonly FilterDef[]; readonly source: Pick, "filterTree" | "setFilterTree">; readonly labels?: TableLabels; readonly classNames?: FilterTreeClassNames; readonly registry?: FilterTypeRegistry; /** Open Advanced on first paint. Default: open only when a tree already exists. */ readonly defaultExpanded?: boolean; } /** One option in a tree Select. */ interface FilterTreeOption { readonly value: string; readonly label: string; } /** Kit Select the tree layout calls. */ interface FilterTreeSelectProps { readonly label: string; readonly value: string; readonly part: string; readonly options: readonly FilterTreeOption[]; readonly className?: string; readonly fieldClassName?: string; readonly labelClassName?: string; readonly onChange: (value: string) => void; } /** Kit text/number/date field the tree layout calls. */ interface FilterTreeInputProps { readonly label: string; readonly value: string; readonly type: "text" | "number" | "date"; readonly className?: string; readonly fieldClassName?: string; readonly labelClassName?: string; readonly onChange: (value: string) => void; } /** Kit button the tree layout calls. */ interface FilterTreeButtonProps { readonly label: string; readonly part?: string; readonly className?: string; readonly onClick: () => void; } /** Kit disclosure that owns the Advanced section's visible chrome. */ interface FilterTreeDisclosureProps { readonly label: string; readonly expanded: boolean; readonly className?: string; readonly summaryClassName?: string; readonly children: ReactNode; readonly onExpandedChange: (expanded: boolean) => void; } /** Adapter-supplied controls for {@link FilterTreeChrome}. */ interface FilterTreeSlots { readonly Select: (props: FilterTreeSelectProps) => ReactNode; readonly Input: (props: FilterTreeInputProps) => ReactNode; readonly Button: (props: FilterTreeButtonProps) => ReactNode; readonly Disclosure: (props: FilterTreeDisclosureProps) => ReactNode; } /** Props for {@link FilterTreeChrome}. */ interface FilterTreeChromeProps extends FilterTreeBuilderProps { readonly slots: FilterTreeSlots; } /** * Recursive AND/OR layout over {@link QueryFilterGroup}. Writes the * versioned `ft` param through `source.setFilterTree`. Adapters supply * the kit controls via {@link FilterTreeSlots}. */ declare function FilterTreeChrome({ defs, source, labels: labelOverrides, classNames, registry, slots, defaultExpanded }: Readonly>): import("react").JSX.Element | null; //#endregion //#region src/find/FindBar.d.ts /** Props for an adapter {@link FindBar} — no slots on the public API. */ interface FindBarProps { /** The find state, straight from `shell.find`. */ find: FindInTableState; /** Labels; falls back to the built-in English. */ labels?: TableLabels; /** A kit's own class for the bar. */ className?: string; } /** Kit search field the find bar calls. */ interface FindSearchProps { readonly label: string; readonly placeholder: string; readonly value: string; readonly focusRef: (node: { focus: () => void; } | null) => void; readonly onChange: (value: string) => void; readonly onKeyDown: (event: KeyboardEvent) => void; } /** One find-bar glyph. */ type FindButtonKind = "previous" | "next" | "close"; /** Kit button the find bar calls. */ interface FindButtonProps { readonly label: string; readonly part: string; readonly kind: FindButtonKind; readonly disabled?: boolean; readonly onClick: () => void; } /** Adapter-supplied controls for {@link FindBarChrome}. */ interface FindBarSlots { readonly Search: (props: FindSearchProps) => ReactNode; readonly Button: (props: FindButtonProps) => ReactNode; } /** Props for {@link FindBarChrome}. */ interface FindBarChromeProps extends FindBarProps { readonly slots: FindBarSlots; } /** * Renders the find bar, or nothing when it is closed — so an adapter renders * it unconditionally and the opt-in promise still holds. * * Enter walks forward, Shift+Enter walks back and Escape closes, which is what * every find bar does and therefore what nobody should have to learn. */ declare function FindBarChrome({ find, labels, className, slots }: Readonly): ReactElement | null; //#endregion //#region src/focus/ColumnSelectCheckbox.d.ts /** The kit checkbox {@link ColumnSelectCheckboxChrome} calls. */ interface ColumnSelectCheckboxProps { /** Accessible name, already localized and already naming the column. */ readonly label: string; /** Whether this column is the selection. */ readonly checked: boolean; /** Select this column, or clear the selection when it already is. */ readonly onToggle: () => void; } /** Adapter-supplied control for {@link ColumnSelectCheckboxChrome}. */ interface ColumnSelectSlots { readonly Checkbox: (props: ColumnSelectCheckboxProps) => ReactNode; } /** Props for {@link ColumnSelectCheckboxChrome}. */ interface ColumnSelectCheckboxChromeProps { /** Accessible name for the control, already localized. */ readonly label: string; /** Whether this column is the selection. */ readonly checked: boolean; /** Select this column, or clear the selection when it already is. */ readonly onToggle: () => void; /** `classNames.columnSelect`, for the kits that carry per-part classes. */ readonly className?: string; /** The kit's checkbox. */ readonly slots: ColumnSelectSlots; } /** * The header checkbox that selects a whole column. * * Ctrl/Cmd+click on a header is the gesture, and it is unchanged. This is the * same state reached two other ways: by a finger, which has no modifier key to * hold, and by a screen reader, which has no way to discover a gesture nothing * announces. * * Core owns the structure, the part name, the accessible name and the two * things that stop the control from fighting the header it sits in: * * - **Clicks do not reach the header.** A sortable header sorts on click and a * plain header selects on click; either would fire underneath the checkbox * and undo what ticking it just did. * - **Keys do not reach the grid.** Space on a checkbox toggles it. Space on a * cell belongs to the grid, and the two are the same keystroke. * * On a hovering pointer the box holds its space and fades in on hover or focus, * so a table of twelve columns is not a row of twelve checkboxes; the layout * never moves, and a selected column shows its state whether or not the pointer * is near. Where there is no hover, it is always visible. */ declare function ColumnSelectCheckboxChrome({ label, checked, onToggle, className, slots }: Readonly): import("react").JSX.Element; /** * The checkbox's accessible name: what it does, and which column. * * "Select column" twelve times over names nothing — a screen reader user * hearing it has no idea which column is about to be selected. */ declare function columnSelectLabel(label: string | undefined, column: { header?: ReactNode; key: string; }): string; //#endregion //#region src/focus/FillHandle.d.ts /** Props passed to an adapter's visible fill-handle component. */ interface FillHandleSlotProps { /** Localized accessible title for the pointer affordance. */ readonly label: string; /** Event handlers and drag metadata from the grid-focus engine. */ readonly handleProps: Readonly>; /** Adapter-defined class supplied by its table component. */ readonly className?: string; } /** Adapter-owned rendering for {@link FillHandleChrome}. */ interface FillHandleSlots { readonly Handle: (props: FillHandleSlotProps) => ReactNode; } /** Props for {@link FillHandleChrome}. */ interface FillHandleChromeProps { /** The grid focus state, straight from `table.gridFocus`. */ readonly focus: GridFocusState | undefined; /** The cell's index in the RENDERED window — what an adapter already has. */ readonly windowIndex: number; /** The cell's column index. */ readonly col: number; /** Where the rendered window starts in the dataset. Zero unless paged. */ readonly firstRowIndex?: number; /** A kit's own class for the visible affordance. */ readonly className?: string; /** Adapter-owned visible component. */ readonly slots: FillHandleSlots; } /** * Renders the fill handle when this cell is the selection's corner, and * nothing at all otherwise — so an adapter renders it unconditionally in every * cell and the opt-in promise still holds. */ declare function FillHandleChrome({ focus, windowIndex, col, firstRowIndex, className, slots }: Readonly): ReactNode; //#endregion //#region src/focus/GridFocusAnnouncer.d.ts /** Props for {@link GridFocusAnnouncer}. */ interface GridFocusAnnouncerProps { /** The grid focus state, straight from `table.gridFocus`. */ focus: GridFocusState; } /** * Renders the grid's focus announcements, or nothing at all when cell * navigation is off — so an adapter spreads it unconditionally and the opt-in * promise still holds. When on, the region is present from the first render and * empty until focus moves, which is the order screen readers need. */ declare function GridFocusAnnouncer({ focus }: Readonly): ReactElement | null; //#endregion //#region src/focus/SelectionStatsBar.d.ts /** Props for {@link SelectionStatsChrome}. */ interface SelectionStatsChromeProps { /** The statistics, straight from `shell.selectionStats`. */ stats: SelectionStats | null; /** Labels for each figure; falls back to the built-in English. */ labels?: TableLabels; /** Locale tag for number formatting. The host's default when omitted. */ locale?: string; /** A kit's own class for the strip. */ className?: string; /** Adapter-owned visible component. */ slots: SelectionStatsSlots; } /** One formatted statistic in display order. */ interface SelectionStatPart { readonly key: "count" | "sum" | "average" | "min" | "max"; readonly text: string; } /** Props passed to an adapter's selection-status component. */ interface SelectionStatsSlotProps { readonly parts: readonly SelectionStatPart[]; readonly className?: string; } /** Adapter-owned rendering for {@link SelectionStatsChrome}. */ interface SelectionStatsSlots { readonly Stats: (props: SelectionStatsSlotProps) => ReactNode; } /** * Renders the selection statistics, or nothing at all when there is no * multi-cell selection — so an adapter renders it unconditionally and the * opt-in promise still holds. * * The strip is a status region: a screen reader reads the new figures after * the range announcement rather than interrupting it, which is the order the * two belong in. */ declare function SelectionStatsChrome({ stats, labels, locale, className, slots }: Readonly): ReactNode; //#endregion //#region src/focus/StatusBarChrome.d.ts /** One piece of the status bar, in display order. */ interface StatusBarItem { /** What this figure is, for a kit that styles them differently. */ readonly key: "rows" | "selected" | FeatureNoticeKind; /** The text to show, already localized and formatted. */ readonly text: string; /** * How the matching feature looks at the table: off, disabled, or * one page. Present on notices; omitted on the row/selected counts. */ readonly appearance?: FeatureNotice["appearance"]; } /** Props an adapter's status-bar component receives. */ interface StatusBarSlotProps { /** The figures, in the order they should read. */ readonly items: readonly StatusBarItem[]; /** The selection statistics, when there are any; render after the items. */ readonly stats: ReactNode; readonly className?: string; } /** Adapter-owned rendering for {@link StatusBarChrome}. */ interface StatusBarSlots { /** The strip itself. */ readonly Bar: (props: StatusBarSlotProps) => ReactNode; /** The selection-stats strip, the same slots that component takes. */ readonly stats: SelectionStatsSlots; } /** What the status bar needs to describe the table. */ interface StatusBarChromeProps { /** * Whether the host asked for the strip. * * Off, this still renders the selection statistics on their own — the * bar HOSTS those figures, so an adapter that chose between the two * itself would carry the same "or they print twice" rule seven times * over. One element, one place that knows. */ enabled: boolean; /** How many rows are rendered right now. */ shown: number; /** The page being shown, for the row range. Defaults to the first. */ page?: number; /** The page size, for the row range. Defaults to {@link shown}. */ limit?: number; /** How many rows the whole filtered set holds, when the source knows. */ total?: number; /** How many rows are selected. */ selected: number; /** The multi-cell selection's figures, straight from `shell.selectionStats`. */ stats: SelectionStats | null; /** Labels for each figure; falls back to the built-in English. */ labels?: TableLabels; /** Locale tag for number formatting. The host's default when omitted. */ locale?: string; /** A kit's own class for the strip. */ className?: string; /** * Opted-in features that cannot run. Always shown — the person at the * table must see them even when the host did not ask for `statusBar`. * Row/selected counts still require `enabled`. */ notices?: readonly FeatureNotice[]; /** Adapter-owned visible components. */ slots: StatusBarSlots; } /** * Renders the status bar. * * @param props - The counts, the selection figures, and the kit's slots. * @returns The strip. */ declare function StatusBarChrome(props: Readonly): import("react").JSX.Element; //#endregion //#region src/grouping/GroupMoreButton.d.ts /** Props for an adapter {@link GroupMoreButton} — no slots on the public API. */ interface GroupMoreButtonProps { /** Whether this offers more groups or more rows inside one. */ scope: "groups" | "rows"; /** How many are still hidden. */ remaining: number; /** The group whose rows are being revealed, for a `"rows"` offer. */ groupKey?: string; /** Labels; falls back to the built-in English. */ labels: Required; /** Reveal the next page. */ onShowMore: (entry: { scope: "groups" | "rows"; groupKey?: string; }) => void; } /** Kit button the group-more chrome calls. */ interface GroupMoreButtonSlotProps { readonly label: string; readonly onClick: () => void; } /** Adapter-supplied controls for {@link GroupMoreButtonChrome}. */ interface GroupMoreButtonSlots { readonly Button: (props: GroupMoreButtonSlotProps) => ReactNode; } /** Props for {@link GroupMoreButtonChrome}. */ interface GroupMoreButtonChromeProps extends GroupMoreButtonProps { readonly slots: GroupMoreButtonSlots; } /** Renders the offer through the adapter's button. */ declare function GroupMoreButtonChrome({ scope, remaining, groupKey, labels, onShowMore, slots }: Readonly): ReactElement; //#endregion //#region src/grouping/GroupToggleSpacer.d.ts /** Renders an inert element the size of a group's toggle button. */ declare function GroupToggleSpacer(): ReactElement; //#endregion //#region src/hooks/useMountStagger.d.ts /** Tuning for the mount stagger. */ interface MountStaggerOptions { /** Master switch. When `false`, the hook is a no-op. */ enabled: boolean; /** Per-item delay in ms. Defaults to 40. */ step?: number; /** Tween duration in ms. Defaults to 320. */ duration?: number; } /** * Dependency-free entrance stagger using the Web Animations API. Animates * descendants marked with `data-stagger` once on mount (and whenever * `deps` change), honoring `prefers-reduced-motion`. Works without GSAP; * GSAP fans can swap in their own hook of the same shape. * * Kit-agnostic: every adapter emits `[data-stagger]` on its row/card * elements and calls this from its `` when `animate` is on. * * @param ref - Ref to the container whose `[data-stagger]` items animate. * @param deps - Re-run the stagger when these change (e.g. the row set). * @param options - See {@link MountStaggerOptions}. */ declare function useMountStagger(ref: RefObject, deps: DependencyList, options: MountStaggerOptions): void; //#endregion //#region src/icons.d.ts /** * Shared chrome glyphs (currentColor, no icon-lib dependency) used by the * toolbar across adapters — a funnel for the Filters button and a magnifier * for the search field. Centralising them keeps every adapter's toolbar * identical and avoids cross-adapter duplication of the SVG markup. */ /** Three-line funnel glyph for the Filters button. */ declare function FiltersIcon(): ReactElement; /** Magnifier glyph for the search field. */ declare function SearchIcon(): ReactElement; /** * Inline expand chevron: points into the row (flipped for RTL) and rotates to * point down while the detail panel is open. Shared by every adapter's * desktop row + mobile card so the expand affordance is identical. */ declare function ExpandChevron({ open, dir }: Readonly<{ open: boolean; dir?: "rtl" | "ltr"; }>): ReactElement; //#endregion //#region src/virtual/useColumnWindow.d.ts /** What {@link useColumnWindow} needs. */ interface UseColumnWindowOptions { /** The columns as rendered, in order. */ columns: readonly ColumnDef[]; /** Off unless the host asked for it and the table is wide enough to need it. */ enabled: boolean; /** Measured or declared widths, by column key. */ widths?: Readonly>; /** Keys that are pinned, and so always rendered. */ pinnedKeys?: ReadonlySet; /** The horizontal scroll container. */ getScrollElement?: () => HTMLElement | null; /** Columns to render either side of the visible span. Defaults to 3. */ overscan?: number; } /** The windowed columns and the space the rest occupies. */ interface ColumnWindow { /** Whether the returned columns are a window rather than everything. */ enabled: boolean; /** The columns to render, pinned ones included. */ columns: readonly ColumnDef[]; /** Width of the spacer before the window, in pixels. */ paddingStart: number; /** Width of the spacer after it. */ paddingEnd: number; } /** * Window a table's columns to what is scrolled into view. * * @typeParam TRow - The row type. * @param options - See {@link UseColumnWindowOptions}. * @returns The window; every column and no spacers when disabled. */ declare function useColumnWindow(options: UseColumnWindowOptions): ColumnWindow; //#endregion //#region src/tableRenderProps.d.ts interface SharedTableRenderProps { /** The resolved table model from `useDataTable`. */ table: UseDataTableResult; /** The rows to render for the current page/window. */ rows: readonly TRow[]; /** * Cell-navigation getters, from the shell. Inert unless `cellNavigation` is * set, so a renderer spreads them unconditionally. */ gridFocus?: GridFocusState; /** Per-row actions rendered in a trailing actions column. */ rowActions?: RowAction[]; /** How those actions render. Omit / `"buttons"` is the horizontal strip. */ rowActionsLayout?: RowActionsLayout; /** * Replace the trailing actions cell. Wins over * {@link SharedTableRenderProps.rowActionsLayout}. */ renderRowActions?: RowActionsRenderer; /** Confirmation handler used before destructive row actions run. */ confirm: ConfirmHandler; /** Stable row identity used for keys and selection. */ getRowId: (row: TRow) => string; /** Hover-prefetch callback fired on desktop row mouse-enter. */ prefetch?: (row: TRow) => void; /** Row activation handler — see `BaseDataTableProps.onRowClick`. */ onRowClick?: (row: TRow) => void; /** Conditional per-row class — see `BaseDataTableProps.rowClassName`. */ rowClassName?: (row: TRow, index: number) => string | undefined; /** When true, group headers render a collapse toggle. */ collapsibleColumnGroups?: boolean; /** Collapsed column-group ids from the layout. */ collapsedColumnGroups?: readonly string[]; /** Tree groups for the declared columns — collapse options, header align. */ columnGroups?: ReadonlyMap>; /** Toggle one column group. No-op unless collapse is armed. */ onToggleColumnGroup?: (id: string) => void; /** Conditional per-row style — see `BaseDataTableProps.rowStyle`. */ rowStyle?: RowStyle; /** Per-row height — see `BaseDataTableProps.rowHeight`. */ rowHeight?: RowHeight; /** Detail-panel renderer — see `BaseDataTableProps.renderRowDetail`. */ renderRowDetail?: (row: TRow) => ReactNode; /** Custom mobile-card body — see `BaseDataTableProps.renderCard`. */ renderCard?: MobileCardRenderer; /** Footer summary builder — see `BaseDataTableProps.summaryRow`. */ summaryRow?: (rows: readonly TRow[]) => Partial>; /** * Row-reorder bundle — present iff the host passed `onRowReorder` and * grouping/tree are off. Omit it and no handle renders. */ rowReorder?: RowReorderState; /** * Dataset offset of the first rendered row (page start). Zero when the * source is not paged. Added to each row's local index so the host hears * dataset-relative `from` / `to`. */ windowStart?: number; /** Whether the injected reorder column is start-pinned. */ reorderPinned?: boolean; /** * Top-pinned rows, already removed from {@link SharedTableRenderProps.rows} * / the virtual window. Render in a sticky section above the scroll body. */ pinnedTopRows?: readonly TRow[]; /** * Bottom-pinned rows, already removed from the scroll body. Render in a * sticky section below it. */ pinnedBottomRows?: readonly TRow[]; /** Headless pin state — actions live on `rowActions`; this is the lists. */ rowPinning?: RowPinningState; /** * Per-cell span. When set (or a column declares `colSpan`/`rowSpan`), * {@link TableRenderModel.cellsByRow} omits covered cells. */ getCellSpan?: GetCellSpan; /** * How a spanned cell is painted. Omit / `"merged"` is the spreadsheet look. * `"plain"` is geometry only. */ cellSpanAppearance?: CellSpanAppearance; /** Host-injected separator / full-width slots. */ extraRows?: readonly ExtraRow[]; /** Expansion state, present when `renderRowDetail` is set. */ expansion?: RowExpansionState; /** * Inline cell-editing bundle — present iff the host passed `onCellEdit`. * Omit it and every cell stays plain display (package DNA: opt-in). */ editing?: EditableCellEditing; /** * Tree bundle — present iff the host declared a hierarchy. Adapters render * `tree.entries` in place of plain rows and put a {@link TreeToggle} plus * `treeIndentStyle` in the `tree.columnKey` cell. */ tree?: { entries: readonly TreeEntry[]; expansion: TreeExpansionState; columnKey?: string; /** Nodes fetching their children right now (`onLoadChildren`). */ loadingIds?: ReadonlySet; /** Nodes whose last fetch rejected — closed, and clickable again. */ failedIds?: ReadonlySet; }; /** * Row-grouping bundle — present iff chrome armed grouping. Adapters that * do not yet render group headers may ignore it; leaf `rows` stay valid. */ grouping?: { /** The grouping keys in order — one for a flat group, more for nested. */groupBy: readonly string[]; collapsed: GroupCollapseState; entries: readonly GroupedFlatEntry[]; setGroupBy: (key: GroupByInput) => void; /** Open every group. */ expandAll: () => void; /** Close every group, at every level. */ collapseAll: () => void; /** Show the tree down to `depth` and no further. */ collapseToDepth: (depth: number) => void; /** Reveal the next page of groups, or of one group's rows. */ showMore: (entry: { scope: "groups" | "rows"; groupKey?: string; }) => void; }; /** Virtual row window (with absolute indices) when virtualization is on. */ rowEntries?: readonly VirtualTableRow[]; /** Spacer height above the virtual window. */ paddingTop?: number; /** Spacer height below the virtual window. */ paddingBottom?: number; /** Ref callback that lets the virtualizer measure a row element. */ measureElement?: (element: Element | null) => void; /** * Measure a row together with its open detail panel — used instead of * `measureElement` when the table can expand rows, since the two are * separate elements and the pair is what the window has to size. */ measureRowPair?: RowPairMeasurer; /** * The windowed columns, when the table windows its horizontal axis. The * render model swaps them in, so adapters map over `model.columns` exactly * as before and render the two spacer cells `columnSpacers` describes. */ columnWindow?: ColumnWindow; /** * Whether the table fits its container rather than overflowing it. Adapters * spread `fittedTableStyle(fitColumns)` onto their `
`: percentage * widths only mean anything under a fixed table layout. */ fitColumns?: boolean; /** * Compact per-column filter row under the header. Desktop only. * Driven by {@link filterDefs} and the source extra bag. */ headerFilters?: boolean; /** * Close a header-filter overlay after a finished single-control write. * Default off — see {@link BaseDataTableProps.closeHeaderFilterOnSelect}. */ closeHeaderFilterOnSelect?: boolean; /** Declarative filter defs the header row matches to columns. */ filterDefs?: readonly FilterDef[]; /** Type registry the header row and custom widgets read. */ filterRegistry?: FilterTypeRegistry; /** Whether the header sticks to the top of the scroll box. */ stickyHeader?: boolean; /** Offset (px) applied to the sticky header top. */ stickyTop?: number; /** Resolve a pinned column's side + inset (px), or `undefined` if unpinned. */ pinOffset?: (key: string) => PinOffset | undefined; /** Optional max height (px) that turns the table into a scroll box. */ maxHeight?: number; /** * Attach to the `maxHeight` scroll box so an element-mode virtual window * tracks the box's scrolling (from `useChromeBodyData`). */ virtualScrollRef?: (node: HTMLElement | null) => void; /** Commit a new width (px) for a resizable column. */ setWidth?: (key: string, width: number) => void; /** Current per-column widths (px), keyed by column key. */ columnWidths?: Readonly>; /** Accessible label for a column-resize handle. */ resizeLabel?: string; } /** The shared prelude every table/card renderer derives before rendering. */ interface TableRenderModel { columns: readonly ColumnDef[]; selection: SelectionState | null; labels: Required; /** Whether a trailing actions column/section renders. */ showActions: boolean; /** Whether the leading reorder column renders. */ showReorder: boolean; /** * Leading control cells before data: expansion + reorder + selection. * Group headers and summaries use this so their colSpans stay aligned. */ leadingCells: number; /** Materialised row entries (virtual window or the full set). */ entries: readonly VirtualTableRow[]; /** Spacer/detail colSpan: expansion + reorder + selection + data + actions. */ columnSpan: number; /** * Widths of the spacer cells holding open the columns outside the window, * or `undefined` when every column is rendered. A row renders one before its * cells and one after them. */ columnSpacers?: { start: number; end: number; }; /** * Per-row body cells. Kits map this instead of `columns` so a span is * one `
` and covered neighbours are already gone. */ cellsByRow: ReadonlyMap[]>; /** * Table-slot indexes a continuing row span already owns on extras in * front of this person (`beforeRowId`). Extra rows omit a `` there. */ extraCoveredSlots: ReadonlyMap>; } /** * Derive the shared render prelude from {@link SharedTableRenderProps} — * extracted so each adapter's renderer doesn't repeat the identical block * (and trip the duplication gate). * * @typeParam TRow - The row type. */ declare function tableRenderModel(props: Pick, "table" | "rows" | "rowActions" | "getRowId" | "rowEntries" | "renderRowDetail" | "expansion" | "columnWindow" | "editing" | "rowReorder" | "pinnedTopRows" | "pinnedBottomRows" | "getCellSpan" | "pinOffset" | "tree" | "grouping" | "extraRows">): TableRenderModel; /** * Memoised `summaryRow` aggregation: re-executes ONLY when the rendered * rows change, never on unrelated table re-renders (a search keystroke, * a checkbox toggle). The builder is read through a ref because callers * routinely pass it inline — a fresh identity every render — and the * aggregate walks the full filtered set, which is exactly the work this * exists to avoid repeating. * * @typeParam TRow - The row type. * @param summaryRow - The caller's summary builder, or `undefined` when off. * @param rows - The rows the summary describes. * @returns The aggregate cells, or `undefined` when no builder is set. */ declare function useSummaryCells(summaryRow: ((rows: readonly TRow[]) => Partial>) | undefined, rows: readonly TRow[]): Partial> | undefined; //#endregion //#region src/layout/desktopTableAssembly.d.ts /** Width (px) reserved for the leading selection column. */ declare const DESKTOP_SELECTION_WIDTH = 48; /** Width (px) reserved for the trailing actions column. */ declare const DESKTOP_ACTIONS_WIDTH = 120; /** Width (px) reserved for the leading expand-chevron column. */ declare const DESKTOP_EXPANSION_WIDTH = 32; /** Per-kit chrome column widths. */ interface DesktopChromeWidths { /** Leading expand-chevron column. Default {@link DESKTOP_EXPANSION_WIDTH}. */ expansion?: number; /** Leading selection column. Default {@link DESKTOP_SELECTION_WIDTH}. */ selection?: number; /** Trailing actions column. Default {@link DESKTOP_ACTIONS_WIDTH}. */ actions?: number; /** * Whether the expand column contributes to start-pin leads. * Most kits yes; unstyled keeps the chevron out of the pin math. */ includeExpansionInLeads?: boolean; } /** Options for {@link useDesktopTableAssembly}. */ interface DesktopAssemblyOptions { /** Chrome column widths. */ widths?: DesktopChromeWidths; } /** Group-shaped body entries adapters hand to their group header. */ type DesktopGroupEntry = Extract, { kind: "group" | "groupFooter" | "groupMore"; }>; /** One host-injected extra in the assembled body. */ interface DesktopExtraSlot { kind: "extra"; key: string; extraKind: "separator" | "fullWidth"; colSpan: number; render?: () => ReactNode; fillStyle?: CSSProperties; } /** Virtual-window spacer. */ interface DesktopVirtualPadSlot { kind: "virtualPad"; key: "pad-top" | "pad-bottom"; height: number; colSpan: number; } /** Group header / footer / more row. */ interface DesktopGroupSlot { kind: "group"; key: string; entry: DesktopGroupEntry; } /** A data row, with wiring already assembled. */ interface DesktopRowSlot { kind: "row"; key: string; wiring: DesktopRowWiring; } /** One visual slot in the assembled tbody, in reading order. */ type DesktopBodySlot = DesktopExtraSlot | DesktopVirtualPadSlot | DesktopGroupSlot | DesktopRowSlot; /** * Shared visual + behaviour inputs for one memoized desktop row. * Adapters extend this with kit extras and paint with their own tags. */ interface DesktopRowWiring { gridFocus?: GridFocusState; row: TRow; index: number; id: string; table: UseDataTableResult; columns: readonly ColumnDef[]; bodyCells: readonly BodyCell[]; spanSignature: string; labels: Required; selected: boolean | undefined; expanded: boolean | undefined; showActions: boolean; showReorder: boolean; rowReorder: SharedTableRenderProps["rowReorder"]; windowStart: number; rowCount: number; reorderPinned: boolean; reorderSignature: string | null; rowPinSide?: RowPinSide; pinRowSticky: boolean; rowPinOffset: number; rowPinSignature: string | null; sourceIndex: number; rowActions: SharedTableRenderProps["rowActions"]; rowActionsLayout: SharedTableRenderProps["rowActionsLayout"]; cellSpanAppearance: SharedTableRenderProps["cellSpanAppearance"]; renderRowActions: SharedTableRenderProps["renderRowActions"]; confirm: ConfirmHandler; columnSpan: number; columnSpacers?: { start: number; end: number; }; treeEntry?: TreeEntry; treeColumnKey?: string; onToggleTree?: (id: string) => void; columnWidths?: Readonly>; pinOffset?: (key: string) => PinOffset | undefined; pinSignature: string; hasStartPin: boolean; hasEndPin: boolean; actionsPinned: boolean; rowClass: string | undefined; rowVisualStyle: CSSProperties | undefined; rowStyleSignature: string; clickable: boolean; hasPrefetch: boolean; editing: EditableCellEditing | undefined; rows: readonly TRow[]; getRowId: (row: TRow) => string; editingSignature: string | null; onRowClick: (row: TRow) => void; onPrefetch: (row: TRow) => void; onToggleSelect: (id: string) => void; onToggleExpand: (id: string) => void; renderDetail: (row: TRow) => ReactNode; measureElement?: (element: Element | null) => void; measureRowPair?: RowPairMeasurer; leads: PinLeads; focusIndex: number; pinPart: ReturnType; pinSticky: ReturnType; edgeRowPin: ReturnType; measureRef: ((element: Element | null) => void) | undefined; /** getRowProps plus grid / click / reorder — spread onto the kit row. */ rowDomProps: Record; bodyPinStyle: (key: string) => CSSProperties | undefined; } /** Assembled sort / resize / filter state for one leaf header cell. */ interface DesktopHeaderLeaf { column: ColumnDef; headerIndex: number; rowSpan: number; headerProps: CellElementProps; columnHeaderProps: Record; style: CSSProperties; sortDir: "asc" | "desc" | undefined; sortActive: boolean; sortButtonProps: SortButtonElementProps; sortIndex: number | undefined; caption: ReactNode; headerDef: FilterDef | undefined; pinSide: PinOffset["side"] | undefined; resizeHandleProps: ColumnResizeHandleProps | undefined; columnName: string; showColumnCheckbox: boolean; columnCheckboxChecked: boolean; onToggleColumn: (() => void) | undefined; columnSelectAriaLabel: string; } /** Pin / scroll / header geometry shared by every HTML-table adapter. */ interface DesktopTablePin { hasPinned: boolean; hasStartPin: boolean; hasEndPin: boolean; stickActions: boolean; signature: string; leads: PinLeads; extraMinWidth: number; expansionLead: number; reorderLead: number; selectionLead: number; pinRowSticky: boolean; rowPinOffset: number; stickyStyle: CSSProperties | undefined; stickyAttr: true | undefined; inScrollBox: boolean; headerStickTop: number; headStyle: (column: { key: string; width?: number | string; }) => CSSProperties | undefined; edgeHeadStyle: (side: "start" | "end", active: boolean) => CSSProperties | undefined; edgeBodyStyle: (side: "start" | "end", active: boolean) => CSSProperties | undefined; } /** Result of {@link useDesktopTableAssembly}. */ interface DesktopTableAssembly { /** Prelude from {@link tableRenderModel} — called, not replaced. */ model: TableRenderModel; summary: Partial> | undefined; showColumnFooter: boolean; headerPlan: readonly (readonly HtmlGroupedHeaderCell[])[] | undefined; headerBand: number; header: { leading: { expand: boolean; reorder: boolean; selection: boolean; spacerStart: boolean; }; trailing: { spacerEnd: boolean; actions: boolean; }; leaf: (column: ColumnDef, headerIndex: number, rowSpan?: number) => DesktopHeaderLeaf; theadRef: RefCallback; headerRowRef: RefCallback; headerRowProps: Record; }; pin: DesktopTablePin; scroll: { overflowing: boolean; boxStyle: CSSProperties | undefined; bindScrollBox: RefCallback; }; tableStyle: CSSProperties | undefined; tableProps: ReturnType["getTableProps"]>; gridProps: Record | undefined; callbacks: { onToggleSelect: (id: string) => void; onToggleExpand: (id: string) => void; onToggleGroup: (groupKey: string) => void; handleRowClick: (row: TRow) => void; handlePrefetch: (row: TRow) => void; renderDetail: (row: TRow) => ReactNode; }; bodySlots: readonly DesktopBodySlot[]; widths: Required> & { reorder: number; includeExpansionInLeads: boolean; }; resizeHandleStyle: CSSProperties; } /** Props {@link useDesktopTableAssembly} reads. */ type DesktopAssemblyProps = SharedTableRenderProps & { /** Whether the injected actions column is user-pinned. */actionsPinned?: boolean; }; /** * One memoized row component per DesktopTable instantiation. * * @typeParam TRow - The row type. * @typeParam TProps - Wiring plus kit extras. * @param RowBase - Kit row painter. * @param extraEqual - Kit-extra comparator (classNames, size, dir). */ declare function createDesktopRow>(RowBase: (props: Readonly) => ReactElement, extraEqual?: (prev: Readonly, next: Readonly) => boolean): import("react").MemoExoticComponent<(props: Readonly) => ReactElement>; /** * Shared desktop-table assembly. Calls {@link tableRenderModel} and * {@link UseDataTableResult.getRowProps}; does not replace them. * * @typeParam TRow - The row type. * @param props - The shared render contract plus actionsPinned. * @param options - Kit chrome widths. */ declare function useDesktopTableAssembly(props: DesktopAssemblyProps, options?: DesktopAssemblyOptions): DesktopTableAssembly; //#endregion //#region src/layout/useStickyToolbarLayout.d.ts /** * Whether the toolbar should pin with the sticky header. * * Inside a table that already scrolls in a box (`maxHeight`, or antd's * native virtual scroller) the toolbar sits *outside* that box — it stays * on screen without `position: sticky`. Pinning it to the page anyway * detaches search from the card while the rows still scroll inside, which * is the ugly double-scroller. */ declare function resolveStickyToolbar(stickyHeader?: boolean, stickyToolbar?: boolean, inScrollBox?: boolean): boolean; /** * Measure the toolbar and return the styles that park it at `stickyTop`, * plus the header inset that keeps thead from sliding under it. */ declare function useStickyToolbarLayout(enabled: boolean, stickyTop?: number): { toolbarRef: RefCallback; toolbarStyle: CSSProperties | undefined; headerOffset: number; }; //#endregion //#region src/pivot/PivotPanelChrome.d.ts /** Props an adapter's panel surface receives. */ interface PivotPanelSurfaceProps { readonly children: ReactNode; readonly className?: string; /** Spread onto the surface — the public part name. */ readonly "data-adapttable-part": "pivot-panel"; } /** Props an adapter's zone receives — one titled list. */ interface PivotZoneProps { /** Which zone this is, for styling and testing. */ readonly zone: PivotZone; /** The zone's caption, already localized. */ readonly label: string; /** Its entries, and the control that adds to it. */ readonly children: ReactNode; /** Spread onto the zone — the public part name. */ readonly "data-adapttable-part": "pivot-zone"; } /** Props an adapter's field row receives. */ interface PivotFieldProps { /** What to call the field. */ readonly label: string; /** Move it one step towards the outside. `undefined` when it is first. */ readonly onMoveUp?: () => void; /** Move it one step towards the inside. `undefined` when it is last. */ readonly onMoveDown?: () => void; /** Take it off this zone. */ readonly onRemove: () => void; /** Accessible names for the three controls. */ readonly moveUpLabel: string; readonly moveDownLabel: string; readonly removeLabel: string; /** The aggregation chooser, for a measure. Absent on a dimension. */ readonly aggregation?: ReactNode; /** Spread onto the field row — the public part name. */ readonly "data-adapttable-part": "pivot-field"; } /** Props an adapter's "add a field" control receives. */ interface PivotAddProps { /** Accessible name. */ readonly label: string; /** The fields that can still be added. Empty means nothing is left. */ readonly options: readonly PivotField[]; /** Add one. */ readonly onAdd: (key: string) => void; } /** Props an adapter's aggregation chooser receives. */ interface PivotAggProps { /** Accessible name. */ readonly label: string; /** The current aggregation. */ readonly value: AggregateName; /** What it can be. */ readonly options: readonly AggregateName[]; /** Change it. */ readonly onChange: (next: AggregateName) => void; } /** The kit-native pieces the panel is built from. */ interface PivotPanelSlots { /** The panel body. */ readonly Surface: (props: PivotPanelSurfaceProps) => ReactNode; /** One titled zone. */ readonly Zone: (props: PivotZoneProps) => ReactNode; /** One field in a zone. */ readonly Field: (props: PivotFieldProps) => ReactNode; /** The control that adds a field to a zone. */ readonly Add: (props: PivotAddProps) => ReactNode; /** The aggregation chooser on a measure. */ readonly Agg: (props: PivotAggProps) => ReactNode; } /** What the panel needs to render. */ interface PivotPanelChromeProps { /** Every field the user can pivot on. */ fields: readonly PivotField[]; /** The configuration being edited. */ config: PivotConfig; /** Report a change. The panel never holds the configuration itself. */ onChange: (next: PivotConfig) => void; /** Labels; falls back to the built-in English. */ labels?: TableLabels; /** The kit's controls. */ slots: PivotPanelSlots; className?: string; } /** * The pivot configuration panel. * * @param props - Fields, the configuration, a change handler and the slots. * @returns The panel, built from the adapter's own controls. */ declare function PivotPanelChrome({ fields, config, onChange, labels: labelsProp, slots, className }: Readonly): import("react").JSX.Element; //#endregion //#region src/rows/rowClickProps.d.ts /** Handlers + affordance for an activatable (clickable) row. */ interface RowClickProps { onClick: (event: MouseEvent) => void; onKeyDown: (event: KeyboardEvent) => void; /** * Roving tab stop: the first row is the list's single Tab entry point; * the rest are reached with ArrowUp/ArrowDown (which move the stop * along). Without a known index every row stays tabbable. */ tabIndex: 0 | -1; /** Marks the element as an arrow-key navigation stop among its siblings. */ "data-adapttable-row": ""; style: { cursor: "pointer"; }; } /** * Build the row-activation props for `onRowClick`: a guarded click handler * (interactive children keep their own behaviour), Enter/Space activation * when the row itself has focus, ArrowUp/ArrowDown roving focus (and tab * stop) across the sibling rows, and the pointer cursor. Returns * `undefined` when no handler is configured, so adapters can spread the * result unconditionally. * * @typeParam TRow - The row type. * @param row - The row this element renders. * @param onRowClick - The caller's activation handler, if any. * @param index - The row's index in the rendered list. When given, only * row 0 is a Tab stop (roving tabindex); omit it and every row stays * tabbable. */ declare function rowClickProps(row: TRow, onRowClick: ((row: TRow) => void) | undefined, index?: number): RowClickProps | undefined; //#endregion //#region src/rows/RowReorderHandle.d.ts /** Props for an adapter {@link RowReorderHandle} — no slots on the public API. */ interface RowReorderHandleProps { reorder: RowReorderState; labels: RowReorderLabels; rowId: string; localIndex: number; row: TRow; windowStart: number; rowCount: number; className?: string; } /** Kit grip the reorder chrome calls. */ interface RowReorderHandleSlotProps { readonly label: string; readonly pressed: boolean; readonly dragging: boolean; readonly className?: string; readonly dragProps: ReturnType["dragProps"]>; readonly onKeyDown: (event: KeyboardEvent) => void; } /** Adapter-supplied controls for {@link RowReorderHandleChrome}. */ interface RowReorderHandleSlots { readonly Handle: (props: RowReorderHandleSlotProps) => ReactNode; } /** Props for {@link RowReorderHandleChrome}. */ interface RowReorderHandleChromeProps extends RowReorderHandleProps { readonly slots: RowReorderHandleSlots; } /** * Desktop grip: pointer drag plus Space-lift keyboard. Kits wrap this in * their own `` / `` so the cell looks like the rest of the row. */ declare function RowReorderHandleChrome({ reorder, labels, rowId, localIndex, row, windowStart, rowCount, className, slots }: Readonly>): ReactElement; /** Props for an adapter {@link RowReorderButtons} — no slots on the public API. */ interface RowReorderButtonsProps { reorder: RowReorderState; labels: RowReorderLabels; localIndex: number; row: TRow; windowStart: number; rowCount: number; className?: string; upClassName?: string; downClassName?: string; } /** Kit button the mobile reorder chrome calls. */ interface RowReorderMoveButtonProps { readonly label: string; readonly part: string; readonly disabled: boolean; readonly className?: string; readonly onClick: () => void; } /** Adapter-supplied controls for {@link RowReorderButtonsChrome}. */ interface RowReorderButtonsSlots { readonly Button: (props: RowReorderMoveButtonProps) => ReactNode; } /** Props for {@link RowReorderButtonsChrome}. */ interface RowReorderButtonsChromeProps extends RowReorderButtonsProps { readonly slots: RowReorderButtonsSlots; } /** * Mobile up/down — a drag handle on a card is unusable. Each press swaps * with the neighbour; the ends disable rather than wrapping. */ declare function RowReorderButtonsChrome({ reorder, labels, localIndex, row, windowStart, rowCount, className, upClassName, downClassName, slots }: Readonly>): ReactElement; /** The live region for row reorder. Kits mount this only when reorder is armed. */ declare function RowReorderAnnouncer(props: Readonly<{ announcement: string; }>): ReactElement; //#endregion //#region src/sort/sortByOptions.d.ts /** * Build sort-by select options from sortable columns. On mobile the card * layout has no clickable headers, so a "Sort by" select is the only sort * affordance — adapters fall back to these when the caller passes no explicit * `sortByOptions`. * * A column contributes an option when it is `sortable` and has a string label * (its `header`, else `mobileLabel`). Columns with non-string headers and no * `mobileLabel` are skipped — there's nothing to show in the select. * * @typeParam TRow - The row type. * @param columns - The columns to derive from (already layout-filtered). * @returns One option per labellable sortable column, in column order. */ declare function deriveSortByOptions(columns: readonly ColumnDef[]): SortByOption[]; //#endregion //#region src/tree/TreeToggle.d.ts /** Props for an adapter {@link TreeToggle} — no slots on the public API. */ interface TreeToggleProps { /** The row's place in the tree. */ entry: TreeEntry; /** Labels; falls back to the built-in English. */ labels?: TableLabels; /** Open or close this node. */ onToggle: (id: string) => void; /** Class for the chevron — the unstyled kit's `treeToggle` hook. */ toggleClassName?: string; /** Class for a leaf's placeholder — the unstyled kit's `treeSpacer` hook. */ spacerClassName?: string; } /** Kit chevron the tree layout calls. */ interface TreeToggleButtonProps { readonly label: string; readonly expanded: boolean; readonly loading: boolean; readonly className?: string; readonly onClick: () => void; } /** Adapter-supplied controls for {@link TreeToggleChrome}. */ interface TreeToggleSlots { readonly Button: (props: TreeToggleButtonProps) => ReactNode; } /** Props for {@link TreeToggleChrome}. */ interface TreeToggleChromeProps extends TreeToggleProps { readonly slots: TreeToggleSlots; } /** * Renders the chevron for a row with children, or an equal-width spacer for a * leaf so the column stays aligned. */ declare function TreeToggleChrome({ entry, labels, onToggle, toggleClassName, spacerClassName, slots }: Readonly>): ReactElement; //#endregion //#region src/tree/TreeCell.d.ts /** Props for an adapter {@link TreeCell} — no slots on the public API. */ interface TreeCellProps { /** The row's place in the tree; absent on a flat table. */ entry: TreeEntry | undefined; /** This cell's column. */ columnKey: string; /** The column that carries the chevron. */ treeColumnKey: string | undefined; /** Labels; falls back to the built-in English. */ labels?: TableLabels; /** Open or close this node. */ onToggle?: (id: string) => void; /** Class for the wrapper — the unstyled kit's `treeCell` hook. */ className?: string; /** Class for the chevron. */ toggleClassName?: string; /** Class for a leaf's placeholder. */ spacerClassName?: string; /** The cell's own content. */ children: ReactNode; } /** Props for {@link TreeCellChrome}. */ interface TreeCellChromeProps extends TreeCellProps { readonly slots: TreeToggleSlots; } /** * Wrap a cell in its tree chrome when it is the tree column, and pass it * through unchanged when it is not. */ declare function TreeCellChrome({ entry, columnKey, treeColumnKey, labels, onToggle, className, toggleClassName, spacerClassName, children, slots }: Readonly>): ReactElement; //#endregion //#region src/url/SavedViewsPanelChrome.d.ts /** Which control a cluster entry is. Stable across kits, and across renders. */ type SavedViewControlKey = "rename" | "moveUp" | "moveDown" | "default" | "remove"; /** * One control in a row's cluster. * * The adapter maps over these rather than hand-writing five buttons, so a kit * cannot render four of them, order them differently, or miss the disabled * state on the one control this reader may not use. */ interface SavedViewRowControl { /** Which control this is — the React key, and what a test asks for. */ readonly key: SavedViewControlKey; /** The accessible name, already localized. These controls are icon-only. */ readonly label: string; /** The glyph to draw inside the kit's own icon button. */ readonly icon: ReactNode; /** * Run it, or `undefined` when this reader may not — a view someone else * owns, or a move off the end of the list. The adapter renders the control * disabled rather than dropping it: a button that vanishes on the last row * makes every row jump as the list is reordered. */ readonly onPress?: () => void; /** Whether the toggle is currently on. Only the default control sets it. */ readonly pressed?: boolean; /** Destructive, so the kit can reach for its own danger colour. */ readonly danger?: boolean; } /** Props an adapter's panel surface receives. */ interface SavedViewsPanelSurfaceProps { /** The card's heading, already localized. */ readonly title: string; readonly children: ReactNode; /** * Anything the host wants inside the card, under the list — a note about * where the views came from, a link to the docs. Outside the card it reads * as a caption belonging to whatever follows it. */ readonly footer?: ReactNode; readonly className?: string; /** Spread onto the surface — the public part name. */ readonly "data-adapttable-part": "saved-views-panel"; } /** Props an adapter's row receives — one saved view and its controls. */ interface SavedViewsPanelRowProps { /** The view's name, or the rename input while it is being edited. */ readonly name: ReactNode; /** That name as plain text — the apply control's accessible name. */ readonly viewName: string; /** Whether the name slot currently holds the rename input. */ readonly isEditing: boolean; /** Whether this is the view the table opens with. */ readonly isDefault: boolean; /** * Whether this reader may change it. A team view someone else owns is * read-only, and the row must SHOW that: every control arrives without a * handler, so a kit that renders them disabled says "not yours" rather than * leaving a button that silently does nothing. */ readonly readOnly: boolean; /** The badge caption for the default view. */ readonly defaultLabel: string; /** The badge caption for a view this reader cannot change. */ readonly readOnlyLabel: string; /** Apply it — what clicking the name does. */ readonly onApply: () => void; /** What applying is called, for the name control's tooltip. */ readonly applyLabel: string; /** The cluster, in order: rename, up, down, default, delete. */ readonly controls: readonly SavedViewRowControl[]; /** * The row's layout, owned by the chrome so a panel reads the same in every * kit: `row` on the row itself, `caption` on the group holding the name and * its badges, `controls` on the cluster, and `control` on each button. The * kit supplies the components; these supply the shape. */ readonly layout: { readonly row: CSSProperties; readonly caption: CSSProperties; readonly controls: CSSProperties; readonly control: CSSProperties; }; /** Spread onto the row — the public part name. */ readonly "data-adapttable-part": "saved-view-row"; } /** Props an adapter's rename input receives. */ interface SavedViewsPanelInputProps { /** Accessible name. */ readonly label: string; /** * Attach to the underlying input element. The panel takes focus through * this rather than through `autoFocus`: the browser attribute fires once at * mount whether or not the element was the point of the interaction, which * is why it reads as an accessibility problem. Here the focus follows a * deliberate click on Rename. * * Kits whose input component hands back something other than the DOM node — * antd's `InputRef`, for one — unwrap it before calling this. */ readonly ref: (element: HTMLInputElement | null) => void; readonly value: string; readonly onChange: (next: string) => void; /** Enter commits, Escape abandons — bind both. */ readonly onCommit: () => void; readonly onCancel: () => void; } /** Props an adapter's empty state receives. */ interface SavedViewsPanelEmptyProps { readonly message: string; } /** The kit-native pieces the panel is built from. */ interface SavedViewsPanelSlots { /** The titled card. */ readonly Surface: (props: SavedViewsPanelSurfaceProps) => ReactNode; /** One view. */ readonly Row: (props: SavedViewsPanelRowProps) => ReactNode; /** The inline rename box. */ readonly Input: (props: SavedViewsPanelInputProps) => ReactNode; /** Shown when nothing has been saved yet. */ readonly Empty: (props: SavedViewsPanelEmptyProps) => ReactNode; } /** What the panel needs to render. */ interface SavedViewsPanelChromeProps { /** The saved views, in list order. */ views: readonly SavedView[]; /** Apply one. */ onApply: (name: string) => void; /** Rename one. */ onRename: (from: string, to: string) => void; /** Move one a step. */ onMove: (name: string, delta: -1 | 1) => void; /** Make one the default, or clear it. */ onSetDefault: (name: string) => void; /** Delete one. */ onRemove: (name: string) => void; /** Labels; falls back to the built-in English. */ labels?: TableLabels; /** Anything of yours that belongs inside the card, under the list. */ footer?: ReactNode; /** The kit's controls. */ slots: SavedViewsPanelSlots; className?: string; } /** * The saved-views management panel. * * @param props - The views, the operations, and the adapter's slots. * @returns The panel, built from the adapter's own controls. */ declare function SavedViewsPanelChrome({ views, onApply, onRename, onMove, onSetDefault, onRemove, labels: labelsProp, footer, slots, className }: Readonly): import("react").JSX.Element; //#endregion //#region src/useDataTableShell.d.ts /** * The kit-agnostic prop surface every batteries-included `` shares: * the base display props plus the three data tiers (`source` / `data` + * `onQueryChange`) and the URL-sync controls. Adapters extend this with * kit-specific extras (slots, classNames, colour, table size) and pass the * whole thing straight through to {@link useDataTableShell}. * * @typeParam TRow - The row type. */ type DataTableShellProps = Omit, "source"> & { /** Full-control tier: a prebuilt source. */source?: TableSource; /** Frontend tier: the raw rows. */ data?: readonly TRow[]; /** Server tier: total row count across all pages. */ total?: number; /** Server tier: a request is in flight. */ loading?: boolean; /** Forwarded error to display in the table's error state. */ error?: Error | null; /** URL-state backend (defaults to the History API). */ urlAdapter?: UrlStateAdapter; /** Sync table state to the URL (default `true`). */ urlSync?: boolean; /** Namespace for this table's URL params. */ urlKey?: string; /** * Server tier: what this endpoint can answer. `supports.facets` * unlocks `query.facets` for checklist counts. */ supports?: QuerySupport; /** * Server tier: keys to send as `query.facets`. Defaults to every * `checklist` definition. */ facetKeys?: readonly string[]; /** Server tier: distinct-value counts from the last fetch. */ facets?: FacetMap; } & DataModeProps; /** * The whole shared orchestration behind a batteries-included ``: * resolve the data tier, build the declarative-filter runtime, wire the table * chrome (selection, columns, pagination, scroll reset, body virtualization), * and assemble the kit-agnostic prop bundles a table renderer and a toolbar * need. The Chakra and Radix adapters are byte-identical here, so this lives * once in core; each adapter supplies only its kit's filter form (via * `renderAutoForm`) and renders its own controls over the returned state. * * @typeParam TRow - The row type. * @param props - The adapter's data-table props. * @param renderAutoForm - Builds the kit's auto-filter form for declarative * filters (called only when there are declarative defs). * @returns The resolved source, chrome, filter node, refs, and the * `tableProps` / `toolbarProps` bundles (sans kit-specific extras). */ declare function useDataTableShell(props: DataTableShellProps, renderAutoForm: (defs: readonly FilterDef[], source: TableSource, registry: FilterTypeRegistry) => ReactNode): { /** Cell-navigation state; inert unless `cellNavigation` is set. */gridFocus: GridFocusState; /** What the selection adds up to; `null` unless `selectionStats` is set. */ selectionStats: SelectionStats | null; /** Undo/redo controls; inert unless `editHistory` is set. */ editHistory: EditHistoryState; /** Find-bar state; inert unless `findInTable` is set. */ find: FindInTableState; source: TableSource; runtime: FilterRuntime; /** The table's resolved URL backend — pass to saved-views UIs. */ urlAdapter: UrlStateAdapter; chrome: TableChrome; table: UseDataTableResult; labels: Required; filtersNode: ReactNode; filtersOpen: boolean; setFiltersOpen: import("react").Dispatch>; filtersTrigger: FilterTriggerToggle; rootRef: import("react").RefObject; /** Fullscreen state, and the portal container overlays need with it. */ fullscreen: FullscreenState; /** Size every rendered column to its content. */ autoSizeColumns: () => number; autoSizeColumn: (key: string) => number; loadMoreRef: import("react").RefObject; canLoadMore: boolean; hasRowActions: boolean; hasRowReorder: boolean; tableProps: { table: UseDataTableResult; gridFocus: GridFocusState; rows: readonly TRow[]; rowActions: RowAction[] | undefined; rowActionsLayout: RowActionsLayout | undefined; renderRowActions: RowActionsRenderer | undefined; actionsPinned: boolean; rowReorder: RowReorderState | undefined; reorderPinned: boolean; pinnedTopRows: readonly TRow[]; pinnedBottomRows: readonly TRow[]; rowPinning: RowPinningState | undefined; getCellSpan: GetCellSpan | undefined; cellSpanAppearance: CellSpanAppearance | undefined; extraRows: readonly ExtraRow[] | undefined; windowStart: number; confirm: ConfirmHandler; getRowId: (row: TRow) => string; rowEntries: readonly VirtualTableRow[] | undefined; paddingTop: number; paddingBottom: number; measureElement: ((node: Element | null) => void) | undefined; measureRowPair: RowPairMeasurer | undefined; columnWindow: ColumnWindow; fitColumns: boolean | undefined; tree: { entries: readonly TreeEntry[]; expansion: TreeExpansionState; columnKey?: string; } | undefined; stickyHeader: boolean | undefined; stickyTop: number | undefined; headerFilters: boolean; closeHeaderFilterOnSelect: boolean; filterDefs: readonly FilterDef[]; filterRegistry: FilterTypeRegistry; pinOffset: (key: string) => PinOffset | undefined; maxHeight: number | undefined; virtualScrollRef: (node: HTMLElement | null) => void; setWidth: ((key: string, width: number | undefined) => void) | undefined; columnWidths: Readonly>; resizeLabel: string; onRowClick: ((row: TRow) => void) | undefined; prefetch: ((row: TRow) => void) | undefined; rowClassName: ((row: TRow, index: number) => string | undefined) | undefined; collapsibleColumnGroups: boolean; collapsedColumnGroups: readonly string[] | undefined; columnGroups: ReadonlyMap>; onToggleColumnGroup: (id: string) => void; rowStyle: RowStyle | undefined; rowHeight: RowHeight | undefined; renderRowDetail: ((row: TRow) => ReactNode) | undefined; renderCard: MobileCardRenderer | undefined; summaryRow: ((rows: readonly TRow[]) => Partial>) | undefined; expansion: RowExpansionState | undefined; editing: EditableCellEditing | undefined; grouping: { groupBy: readonly string[]; collapsed: GroupCollapseState; aggregates?: GroupAggregatesFn | undefined; entries: readonly GroupedFlatEntry[]; setGroupBy: (key: GroupByInput) => void; expandAll: () => void; collapseAll: () => void; collapseToDepth: (depth: number) => void; showMore: (entry: { scope: "groups" | "rows"; groupKey?: string; }) => void; } | undefined; dir: Direction | undefined; }; toolbarProps: { dir: Direction | undefined; onExportCsv: (() => void) | undefined; exportBusy: boolean; exportStatus: ExportStatus; exportAnnouncement: string; exportLabel: string; hasFilters: boolean; activeFilterCount: number; filters: ReactNode; onClearFilters: () => void; showRowsPerPage: boolean; onAddRow: (() => void) | undefined; addRowLabel: string; density?: "comfortable" | "compact"; onDensityChange?: ((next: "comfortable" | "compact") => void) | undefined; onToggleFullscreen?: (() => void) | undefined; isFullscreen?: boolean; onPrint?: (() => void) | undefined; printLabel?: string; table: UseDataTableResult; searchable: boolean; searchPlaceholder: string; sortByOptions: SortByOption[]; toolbar: ReactNode; toolbarSlots: ToolbarSlots; onUndo?: (() => void) | undefined; onRedo?: (() => void) | undefined; canUndo?: boolean | undefined; canRedo?: boolean | undefined; undoLabel?: string | undefined; redoLabel?: string | undefined; filtersOpen?: boolean | undefined; onToggleFilters?: (() => void) | undefined; onFiltersTriggerPointerDown?: (() => void) | undefined; savedViewsMenu?: ReactNode; columnMenu?: ReactNode; }; }; //#endregion //#region src/virtual/ColumnSpacer.d.ts /** Props for {@link ColumnSpacer}. */ interface ColumnSpacerProps { /** Pixel width of the columns this cell stands in for. */ width: number; /** Which side of the window it sits on, for the part name. */ side: "start" | "end"; /** The element to render — a kit's own cell component, or `"td"`. */ as?: "td" | "th"; } /** Renders the spacer, or nothing when there is nothing to hold open. */ declare function ColumnSpacer({ width, side, as }: Readonly): ReactElement | null; //#endregion export { BatchEditBarChrome, type BatchEditBarChromeProps, type BatchEditBarProps, type BatchEditBarSlots, type BatchEditButtonProps, BatchEditCell, type BatchEditCellProps, type BodyCell, type BulkBarChromeProps, type BulkBarState, COLUMN_DND_MIME, COLUMN_GROUP_ID_SEP, COLUMN_GROUP_RENDER_PREFIX, COLUMN_GROUP_STUB_PREFIX, COLUMN_GROUP_STUB_WIDTH, type CellSpanAppearance, type ChecklistButtonProps, type ChecklistCheckboxProps, ChecklistChrome, type ChecklistChromeProps, type ChecklistClassNames, type ChecklistFilterProps, type ChecklistSearchProps, type ChecklistSlots, type ColumnDragRowAttrs, type ColumnDragState, type ColumnDropProps, type ColumnGroupDef, type ColumnGroupToggleButtonProps, ColumnGroupToggleChrome, type ColumnGroupToggleChromeProps, type ColumnGroupToggleProps, type ColumnGroupToggleSlots, type ColumnInput, type ColumnMenuAction, type ColumnMenuActionContext, type ColumnMenuChromeProps, type ColumnMenuLabels, type ColumnMenuRow, type ColumnReorderKeyProps, type ColumnResizeHandleProps, type ColumnRowDragProps, ColumnSelectCheckboxChrome, type ColumnSelectCheckboxChromeProps, type ColumnSelectCheckboxProps, type ColumnSelectSlots, type ColumnSizingOptions, ColumnSpacer, type ColumnSpacerProps, type ColumnWindow, CommandPaletteChrome, type CommandPaletteChromeProps, type CommandPaletteInputProps, type CommandPaletteItemProps, type CommandPaletteSlots, type CommandPaletteSurfaceProps, ContextMenuChrome, type ContextMenuChromeProps, type ContextMenuItemProps, type ContextMenuSlots, type ContextMenuSurfaceProps, DEFAULT_CARD_SIZE_PX, DESKTOP_ACTIONS_WIDTH, DESKTOP_EXPANSION_WIDTH, DESKTOP_SELECTION_WIDTH, type DataModeProps, type DataTableShellProps, type DesktopAssemblyOptions, type DesktopAssemblyProps, type DesktopBodySlot, type DesktopChromeWidths, type DesktopExtraSlot, type DesktopGroupEntry, type DesktopGroupSlot, type DesktopHeaderLeaf, type DesktopRowSlot, type DesktopRowWiring, type DesktopTableAssembly, type DesktopTablePin, type DesktopVirtualPadSlot, EXTRA_OVER_SPAN_ROW_STYLE, EXTRA_OVER_SPAN_STYLE, EXTRA_ROW_PARTS, type EditableCellActivateProps, type EditableCellButtonProps, type EditableCellSlots, ExpandChevron, ExportAnnouncer, type ExportAnnouncerProps, type ExportHandlerState, type ExportStatus, type ExtraEntry, type ExtraRow, EyeIcon, type FeatureNotice, type FeatureNoticeKind, FillHandleChrome, type FillHandleChromeProps, type FillHandleSlotProps, type FillHandleSlots, FilterHeaderChrome, type FilterHeaderChromeProps, type FilterHeaderClassNames, FilterHeaderControlChrome, type FilterHeaderControlChromeProps, type FilterHeaderControlProps, type FilterHeaderMultiProps, type FilterHeaderOption, type FilterHeaderRangeProps, type FilterHeaderRowProps, type FilterHeaderSearchProps, type FilterHeaderSelectProps, type FilterHeaderSlots, type FilterTreeBuilderProps, type FilterTreeButtonProps, FilterTreeChrome, type FilterTreeChromeProps, type FilterTreeClassNames, type FilterTreeDisclosureProps, type FilterTreeInputProps, type FilterTreeOption, type FilterTreeSelectProps, type FilterTreeSlots, type FilterTriggerToggle, FiltersIcon, FindBarChrome, type FindBarChromeProps, type FindBarProps, type FindBarSlots, type FindButtonKind, type FindButtonProps, type FindSearchProps, type FullscreenState, GridFocusAnnouncer, type GridFocusAnnouncerProps, GripIcon, GroupMoreButtonChrome, type GroupMoreButtonChromeProps, type GroupMoreButtonProps, type GroupMoreButtonSlotProps, type GroupMoreButtonSlots, type GroupRowKind, GroupToggleSpacer, type HeaderGroupCell, type HtmlGroupedHeaderCell, type KeyedVirtualization, LiveRegion, type LiveRegionProps, type MountStaggerOptions, type NestedTableParent, PINNED_BOTTOM_PART, PINNED_TOP_PART, type PaginationItem, type PaginationSlot, PinIcon, type PinLeads, type PinOffset, type PinnedCellStyle, type PinnedSide, type PivotAddProps, type PivotAggProps, type PivotFieldProps, PivotPanelChrome, type PivotPanelChromeProps, type PivotPanelSlots, type PivotPanelSurfaceProps, type PivotZoneProps, REORDER_COLUMN_WIDTH, ROW_DND_MIME, ROW_ID_ATTRIBUTE, type ResizableVirtualizer, type ResolvedContextTarget, type RowClickProps, RowEditActionsChrome, type RowEditActionsChromeProps, type RowEditActionsProps, type RowEditActionsSlots, type RowEditButtonProps, RowEditCell, type RowEditCellProps, type RowEditControls, type RowEditControlsOptions, type RowHeight, type RowPairMeasurer, RowReorderAnnouncer, RowReorderButtonsChrome, type RowReorderButtonsChromeProps, type RowReorderButtonsProps, type RowReorderButtonsSlots, RowReorderHandleChrome, type RowReorderHandleChromeProps, type RowReorderHandleProps, type RowReorderHandleSlotProps, type RowReorderHandleSlots, type RowReorderMoveButtonProps, type RowReorderState, type RowStyle, SHARED_DESKTOP_ROW_KEYS, type SavedViewControlKey, type SavedViewRowControl, SavedViewsPanelChrome, type SavedViewsPanelChromeProps, type SavedViewsPanelEmptyProps, type SavedViewsPanelInputProps, type SavedViewsPanelRowProps, type SavedViewsPanelSlots, type SavedViewsPanelSurfaceProps, SearchIcon, type SearchInputState, type SelectionStatPart, SelectionStatsChrome, type SelectionStatsChromeProps, type SelectionStatsSlotProps, type SelectionStatsSlots, type SharedTableRenderProps, SidePanelChrome, type SidePanelChromeProps, type SidePanelCloseProps, type SidePanelFrameProps, SidePanelLayout, type SidePanelLayoutProps, type SidePanelSlots, type SidePanelTabProps, StatusBarChrome, type StatusBarChromeProps, type StatusBarItem, type StatusBarSlotProps, type StatusBarSlots, type TableBodyRegion, type TableCommandPalette, type TableContextMenu, type TableRenderModel, type ToolbarChromeProps, TreeCellChrome, type TreeCellChromeProps, type TreeCellProps, type TreeToggleButtonProps, TreeToggleChrome, type TreeToggleChromeProps, type TreeToggleProps, type TreeToggleSlots, type UseBulkBarStateOptions, type UseColumnWindowOptions, type ViewControlsToolbar, type VirtualTableRow, applyCollapsedColumnGroups, bodyCellsHaveRowSpan, bulkActionErrorMessage, cellHighlightStyle, cellSpanMark, cellsForRow, columnFlexShares, columnGroupHeaderCaption, columnGroupId, columnGroupPath, columnGroupStubStyle, columnMenuActions, columnSelectLabel, columnSizeStyle, commitBooleanDraft, createDesktopRow, deriveSortByOptions, editorBusyProps, editorValidationProps, exportButtonLabel, extraCountBeforeRowIds, extraCoveredTableSlots, extraHostFillStyle, extraRowsForSection, extraUncoveredColSpans, fillSlot, filterColumnMenuRows, fittedTableStyle, flattenColumnTree, focusEditorOnMount, groupIndentStyle, groupRowParts, groupedHeaderAlign, groupedHeaderCellStyle, groupedHeaderChildRule, groupedHeaderLabelStyle, headerGroupRow, headerGroupRows, hideAllColumns, htmlGroupedHeaderPlan, inflateBodyCellRowSpans, insertExtraRows, insertExtrasBeforeRows, isColumnGroupRenderKey, isColumnGroupStubKey, isColumnGroupSummaryKey, isCurrentMatchCell, isExtraEntry, isMatchedCell, isSelectedCell, logicalAlign, mergedCellStyle, multiDraftFromSelect, nestedTableDefaults, nestedTableDetail, nextPinSide, orderedCardEntries, paginationItems, paginationSlots, pinActionLabel, pinnedColumnWidth, pinnedDataCellStyle, pinnedEdgeCellStyle, pinnedRowCellStyle, pinnedRowPart, pinnedRowSticky, pinnedRowStickyStyle, printToolbar, resetColumnLayout, resolveContextTarget, resolveDisabledReason, resolveMobileLabel, resolveRowHeight, resolveRowStyle, resolveStickyToolbar, resolveVirtualRows, rowClickProps, rowEditControls, rowEditingSignature, rowIsDirty, rowPinSignature, rowReorderDropStyle, rowReorderSignature, rowSourceIndex, rowSpanSignature, rowStyleSignature, shallowEqualByKeys, showAllColumns, sortArrow, tableErrorState, tableRenderModel, toggleCollapsedColumnGroup, undoRedoToolbar, unpinAllColumns, useBulkBarState, useColumnWindow, useCommandPalette, useDataTableShell, useDesktopTableAssembly, useExportHandler, useFullscreen, useKeyedVirtualization, useMountStagger, useOffsetHeight, useResolvedAdapter, useRowPairMeasurer, useStickyToolbarLayout, useSummaryCells, useTableContextMenu, viewControlsToolbar }; //# sourceMappingURL=adapter.d.ts.map