themelia-react-ui 2.0.5 → 3.0.0

package/dist/components/features/rich-text-editor/partials/rich-text-editor-toolbar.d.ts

@@ -6,6 +6,8 @@ export interface RichTextEditorToolbarProps {
     buttons: ToolbarButtonConfig[];
     /** Additional controls appended to the toolbar. */
     extraToolbarItems?: ReadonlyArray<RichTextEditorToolbarItem>;
+    /** Active values read from the editor's transaction subscription. */
+    extraToolbarActive?: readonly boolean[];
     /** Hides the control that switches to HTML source. */
     hideSourceToggle?: boolean;
     /** Whether the editor is currently showing HTML source. */
@@ -15,9 +17,8 @@ export interface RichTextEditorToolbarProps {
     /** Renders the entry as unselectable. */
     disabled?: boolean;
     /**
-     * The TipTap variant disables built-in buttons until the editor instance
-     * is ready; the fallback variant simply marks them disabled. This flag
-     * lets callers force the disabled state without re-deriving it per button.
+     * Built-in buttons stay disabled until the editor instance is ready. This
+     * flag lets callers force the disabled state without re-deriving it per button.
      */
     hasEditor?: boolean;
     /** Content pinned to the end of the toolbar. */
@@ -27,7 +28,7 @@ export interface RichTextEditorToolbarProps {
     /** Merged onto the outermost node. */
     className?: string;
 }
-export declare function RichTextEditorToolbar({ buttons, extraToolbarItems, hideSourceToggle, sourceMode, toggleSourceMode, disabled, hasEditor, toolbarTrailing, strings, className, }: RichTextEditorToolbarProps): import("react").JSX.Element;
+export declare function RichTextEditorToolbar({ buttons, extraToolbarItems, extraToolbarActive, hideSourceToggle, sourceMode, toggleSourceMode, disabled, hasEditor, toolbarTrailing, strings, className, }: RichTextEditorToolbarProps): import("react").JSX.Element;
 export declare namespace RichTextEditorToolbar {
     var displayName: string;
 }

package/dist/components/features/rich-text-editor/rich-text-editor.recipes.d.ts

@@ -11,7 +11,7 @@ export declare const richTextEditorRecipes: {
     readonly placeholder: "pointer-events-none absolute inset-0 p-surface-xs";
     /** Inline inset for the regions under the body (image details, counts, footer slot). */
     readonly regionX: "px-surface-xs";
-    readonly frame: "min-w-0 overflow-hidden border-input bg-background rounded-radius border";
+    readonly frame: string;
     readonly disabled: "opacity-50";
     readonly disabledControl: "disabled:opacity-100 aria-disabled:opacity-100";
     readonly content: "h-full [&_.ProseMirror]:h-full [&_.ProseMirror]:min-h-full [&_.ProseMirror]:outline-none";

package/dist/components/features/rich-text-editor/rich-text-editor.types.d.ts

@@ -1,5 +1,6 @@
-import type { ComponentType, ReactNode } from 'react';
+import type { ComponentType, FocusEventHandler, ReactNode } from 'react';
 import type * as TiptapReact from '@tiptap/react';
+import type { FieldControlAttributes } from '../../../lib/field-control-attributes';
 import type { StringsProp } from '../../../lib/strings';
 import type { RichTextImageRendering } from '../../typography/rich-text';
 import type { RichTextEditorStrings } from './rich-text-editor.strings';
@@ -27,6 +28,11 @@ export interface RichTextCaretContext {
 export interface RichTextEditorHandle {
     focus(): void;
     getHTML(): string;
+    /**
+     * Replaces the document and reports it through `onValueChange`. Called from
+     * inside `onValueChange` with the current `value`, it rejects the reported
+     * change: the document is restored and nothing further is reported.
+     */
     setHTML(html: string): void;
     /** Inserts raw HTML at the current selection. */
     insertHTML(html: string): void;
@@ -94,11 +100,22 @@ export interface RichTextEditorImages extends RichTextImageRendering {
 }
 /** Body floor roles for the rich text editor. */
 export type RichTextEditorBodyHeight = 'control' | 'field' | 'document';
-export interface RichTextEditorProps {
-    /** Editor content as HTML. Controlled. */
+export interface RichTextEditorProps extends FieldControlAttributes {
+    /**
+     * Editor content as HTML. Value-synchronised: the editor owns the document
+     * while the user edits and reports each change through `onValueChange`; a
+     * new `value` replaces the document. Keeping the same `value` after a
+     * reported change leaves the edit in place. To reject or substitute a
+     * change, either set `value` to the replacement (a different string) or
+     * call `setHTML` on the handle.
+     */
     value: string;
-    /** Fired with the next value. */
+    /** Reports the document HTML. Source edits commit when switching back to rich text. */
     onValueChange: (html: string) => void;
+    /** Includes the committed HTML under this name in native form submissions. */
+    name?: string;
+    /** Runs when focus leaves the editor and its toolbar. */
+    onBlur?: FocusEventHandler<HTMLElement>;
     /** Shown while the document is empty. */
     placeholder?: string;
     /** Tightens the toolbar and body for inline use. */
@@ -115,6 +132,8 @@ export interface RichTextEditorProps {
     maxHeight?: string;
     /** Renders the entry as unselectable. */
     disabled?: boolean;
+    /** Marks the editable field invalid and applies the shared field state. */
+    invalid?: boolean;
     /** Show character and word counts in a footer bar. */
     showCounts?: boolean;
     /** Optional character limit — displayed as "X / max" when showCounts is true. */
@@ -137,6 +156,13 @@ export interface RichTextEditorProps {
      * comment composer to detect `@`-style trigger characters.
      */
     onCaretChange?: () => void;
+    /** Consumes an editable-body key before the editor handles it. Return true to handle the key. */
+    onEditorKeyDown?: (event: KeyboardEvent) => boolean;
+    /** Associates the editable body with an open inline completion listbox. */
+    suggestionPopup?: {
+        listboxId: string;
+        activeOptionId?: string;
+    };
     /** Per-instance string overrides (deep-merged over `defaultRichTextEditorStrings`). */
     strings?: StringsProp<RichTextEditorStrings>;
     /**

package/dist/components/features/schema-form/hooks/use-schema-form.d.ts

@@ -15,9 +15,18 @@ export interface UseSchemaFormResult extends SchemaFormSubmitHelpers {
     errors: SchemaFormErrors;
     getFieldError: (key: string) => string | undefined;
     getFieldValue: (key: string) => SchemaFormValue;
+    /** Reads the latest values, including writes made in the current event. */
+    getValues: () => SchemaFormValues;
     setFieldValue: (key: string, value: SchemaFormValue) => void;
     setValues: (values: SchemaFormValues) => void;
+    /** Registers a field editor's current parse validity with form validation. */
+    setFieldParseValidity: (key: string, valid: boolean) => void;
     reset: () => SchemaFormValues;
     validate: () => boolean;
+    /**
+     * Keys the latest `validate()` call rejected, in schema order. Includes
+     * JSON fields whose draft cannot be parsed; empty after a passing run.
+     */
+    getInvalidKeys: () => string[];
 }
-export declare function useSchemaForm({ fields, value, defaultValue, errors: externalErrors, onValueChange, onFieldChange, formatRequiredError, validationError, onError, }: UseSchemaFormOptions): UseSchemaFormResult;
+export declare function useSchemaForm(options: UseSchemaFormOptions): UseSchemaFormResult;

package/dist/components/features/schema-form/partials/schema-form-field.d.ts

@@ -5,8 +5,10 @@ export interface SchemaFormFieldRendererProps extends SchemaFormFieldContext {
     strings: SchemaFormStrings;
     /** Merged onto the outermost node. */
     className?: string;
+    /** Reports whether the JSON editor can parse its current draft. */
+    onParseValidityChange?: (key: string, valid: boolean) => void;
 }
-export declare function SchemaFormFieldRenderer({ field, value, values, error, disabled, required, fieldId, onValueChange, onError, strings, className, }: SchemaFormFieldRendererProps): import("react").JSX.Element;
+export declare function SchemaFormFieldRenderer({ field, value, values, error, disabled, required, fieldId, onValueChange, onError, strings, className, onParseValidityChange, }: SchemaFormFieldRendererProps): import("react").JSX.Element;
 export declare namespace SchemaFormFieldRenderer {
     var displayName: string;
 }

package/dist/components/features/schema-form/schema-form.d.ts

@@ -1,5 +1,5 @@
 import type { SchemaFormProps } from './schema-form.types';
-export declare function SchemaForm({ schema, value, defaultValue, errors, disabled, layout, columns, id, name, title, description, headerSlot, footerSlot, actionsSlot, emptySlot, showActions, submitLabel, resetLabel, submitDisabled, resetDisabled, submitting, onValueChange, onFieldChange, onSubmit, onReset, onError, renderField, renderSection, strings: stringsProp, className, contentClassName, sectionClassName, fieldClassName, }: SchemaFormProps): import("react").JSX.Element;
+export declare function SchemaForm({ schema, value, defaultValue, errors, disabled, layout, columns, id, name, title, description, headerSlot, footerSlot, actionsSlot, emptySlot, showActions, submitDisabled, resetDisabled, submitting, hiddenValues, onValueChange, onFieldChange, onSubmit, onReset, onError, renderField, renderSection, strings: stringsProp, className, contentClassName, sectionClassName, fieldClassName, }: SchemaFormProps): import("react").JSX.Element;
 export declare namespace SchemaForm {
     var displayName: string;
 }

package/dist/components/features/schema-form/schema-form.types.d.ts

@@ -235,16 +235,24 @@ export interface SchemaFormProps {
     emptySlot?: ReactNode;
     /** Renders the actions. */
     showActions?: boolean;
-    /** Copy for the submit button. */
-    submitLabel?: string;
-    /** Copy for the reset button. */
-    resetLabel?: string;
     /** Disables the submit button. */
     submitDisabled?: boolean;
     /** Disables the reset button. */
     resetDisabled?: boolean;
-    /** Shows the pending state on submit and blocks repeat presses. */
+    /**
+     * Shows the pending state on submit and blocks repeat presses. Left
+     * unset, the form shows it while a promise returned by `onSubmit` is
+     * pending. A second submission is ignored until that promise settles
+     * whether or not this prop is set.
+     */
     submitting?: boolean;
+    /**
+     * What `onSubmit` receives for fields whose `hidden` rule currently
+     * applies. `keep` (default) submits every stored value; `omit` leaves
+     * hidden fields out of the payload while keeping their values in form
+     * state, so showing the field again restores what was entered.
+     */
+    hiddenValues?: 'keep' | 'omit';
     onValueChange?: (values: SchemaFormValues) => void;
     onFieldChange?: (key: string, value: SchemaFormValue, values: SchemaFormValues) => void;
     /** Fired when an entry is submitted. */

package/dist/components/features/schema-form/schema-form.utils.d.ts

@@ -10,7 +10,7 @@ export declare function toStringValue(value: SchemaFormValue): string;
 export declare function toStringArray(value: SchemaFormValue): string[];
 export declare function toBooleanValue(value: SchemaFormValue): boolean;
 export declare function parseNumberValue(rawValue: string, integer?: boolean): number | null;
-export declare function formatJsonValue(value: SchemaFormValue, indent?: number): string;
+export declare function formatJsonValue(value: SchemaFormValue, indent?: number, quoteString?: boolean): string;
 export declare function parseJsonValue(rawValue: string): {
     value: SchemaFormValue;
     valid: boolean;

package/dist/components/features/suggestions/suggestions.strings.d.ts

@@ -12,5 +12,19 @@ export interface SuggestionsStrings {
     startTypingMessage: string;
     errorMessage: string;
     retry: string;
+    /**
+     * Hint shown while the query is shorter than `minQueryLength`. `{remaining}`
+     * is replaced by the number of characters still needed and `{s}` by an
+     * English plural suffix; use `formatTypeMore` for other plural rules.
+     */
+    typeMoreMessage?: string;
+    /** Builds the remaining-characters hint from the count. Wins over `typeMoreMessage`. */
+    formatTypeMore?: (remaining: number) => string;
+    /** Accessible name of the control that clears the selection. */
+    clear?: string;
+    /** Accessible name of the control that opens the list. */
+    toggle?: string;
+    /** Accessible name of the screen-reader dismissal controls inside the list. */
+    dismiss?: string;
 }
 export declare const defaultSuggestionsStrings: SuggestionsStrings;

package/dist/components/features/suggestions/suggestions.types.d.ts

@@ -9,13 +9,17 @@ export interface SuggestionsFetchContext {
 export interface UseSuggestionsConfig<T> {
     /** Loads suggestions for a query. Receives an `AbortSignal` for the superseded request. */
     fetchData: (query: string, context?: SuggestionsFetchContext) => MaybePromise<T[]>;
-    /** Characters required before a request is issued. Default: `1`. */
+    /** Characters required before a request is issued, counted without surrounding whitespace. Default: `1`. */
     minQueryLength?: number;
-    /** Quiet period before a request is scheduled, in milliseconds. Default: `250`. */
+    /** Quiet period before a request is scheduled, in milliseconds. Default: `300`, the library-wide debounce. */
     debounceMs?: number;
     /** Extra wait before `fetchData` runs, applied once the loading state is already visible. Default: `0`. */
     requestDelay?: number;
-    /** Issues a request for the empty query so suggestions exist before typing. */
+    /**
+     * Issues a request for the empty query so suggestions exist before typing.
+     * `SuggestionsCombobox` lists them when the empty field is opened, whatever
+     * `minQueryLength` is.
+     */
     preload?: boolean;
     /** Controlled query. */
     query?: string;
@@ -38,7 +42,11 @@ export interface UseSuggestionsConfig<T> {
 }
 export interface UseSuggestionsResult<T> {
     items: T[];
-    /** Replaces the content with the loading state. */
+    /**
+     * Replaces the content with the loading state. True from the moment the
+     * query changes, so the previous query's items are never offered while the
+     * next request is still debounced.
+     */
     isLoading: boolean;
     error: unknown | null;
     isError: boolean;
@@ -68,7 +76,7 @@ export interface SuggestionsComboboxProps<T> extends UseSuggestionsConfig<T> {
     renderError?: (context: SuggestionsErrorRenderContext) => ReactNode;
     /** Shows a control that clears the current selection. */
     allowClear?: boolean;
-    /** Resets the query when the list closes without a selection. */
+    /** Resets the query when a results list closes. Failed queries remain available to retry. */
     clearInputOnClose?: boolean;
     /** Renders the entry as unselectable. */
     disabled?: boolean;

package/dist/components/features/table/data-table.d.ts

@@ -1,6 +1,6 @@
 export declare function useDataTableSize(): 'xs' | 'sm';
 import { type DataTableProps } from './table.types';
-export declare function DataTable<TData extends object, TValue = unknown>({ size, surface, headerTransparent, columns, data, columnGroups, rowActions, rowActionsMenuLabel, rowActionsDisplayMode, rowActionsBreakpoint, enableSorting, enableResizing, enableFiltering, filterColumn, filterPlaceholder, manualSorting, enableColumnVisibility, fullscreen: controlledFullscreen, defaultFullscreen, onFullscreenChange, showFullscreenToggle, enableRowSelection, enableMultiRowSelection, enableSubRowSelection, pagination, pageQueryKey, onPageChange, onSortingChange, onColumnFiltersChange, onRowClick, onRowSelectionChange, stickyHeader, stickyToolbar, stickyFirstColumn, maxBodyHeight, fillAvailableHeight, emptyStateMessage, emptyStateAction, className, rowClassName, cellClassName, headerClassName, wrapperClassName, innerClassName, tableContainerClassName, getRowId, rowSelection: controlledRowSelection, sorting: controlledSorting, defaultSorting, columnVisibility: controlledColumnVisibility, defaultColumnVisibility, initialState, onColumnVisibilityChange, strings: stringsOverride, topbarContent, topbarEnd, topbarClassName, toolbarLabelVisibility, footerContent, selectionToolbar, bulkActions, selectionToolbarClassName, selectionToolbarPlacement, totalRowCount: totalRowCountProp, storageKey, }: DataTableProps<TData, TValue>): import("react").JSX.Element;
+export declare function DataTable<TData extends object, TValue = unknown>({ size, surface, headerTransparent, columns, data, loading, loadingRows, columnGroups, rowActions, rowActionsMenuLabel, rowActionsDisplayMode, rowActionsBreakpoint, enableSorting, enableResizing, filterColumn, manualSorting, enableColumnVisibility, fullscreen: controlledFullscreen, defaultFullscreen, onFullscreenChange, showFullscreenToggle, enableRowSelection, enableMultiRowSelection, pagination, pageQueryKey, onPageChange, onSortingChange, onColumnFiltersChange, onRowClick, onRowSelectionChange, stickyHeader, stickyToolbar, stickyFirstColumn, maxBodyHeight, fillAvailableHeight, emptyStateAction, className, rowClassName, cellClassName, headerClassName, wrapperClassName, innerClassName, tableContainerClassName, getRowId, rowSelection: controlledRowSelection, sorting: controlledSorting, columnVisibility: controlledColumnVisibility, initialState, onColumnVisibilityChange, strings: stringsOverride, topbarContent, topbarEnd, topbarClassName, toolbarLabelVisibility, footerContent, selectionToolbar, bulkActions, selectionToolbarClassName, selectionToolbarPlacement, totalRowCount: totalRowCountProp, storageKey, columnVisibilityPrecedence, }: DataTableProps<TData, TValue>): import("react").JSX.Element;
 export declare namespace DataTable {
     var displayName: string;
 }

package/dist/components/features/table/filter-bar.d.ts

@@ -1,5 +1,5 @@
 import { type DataTableFilterBarProps } from './table.types';
-export declare function DataTableFilterBar<TData>({ table, filterColumn, filterPlaceholder, enableColumnVisibility, customContent, strings, }: DataTableFilterBarProps<TData>): import("react").JSX.Element | null;
+export declare function DataTableFilterBar<TData>({ table, filterColumn, enableColumnVisibility, customContent, strings, }: DataTableFilterBarProps<TData>): import("react").JSX.Element | null;
 export declare namespace DataTableFilterBar {
     var displayName: string;
 }

package/dist/components/features/table/index.d.ts

@@ -9,6 +9,7 @@ export { DataTableToolbar } from './table-toolbar';
 export { CellValue, CellStack, type CellStackProps, type CellStackValue, type CellValueDescriptor, type CellValueKind, type CellValueProps, type CellValueTuple, type PrimitiveCellValue, } from './partials/cell-value';
 export { TableLink, type TableLinkProps } from './partials/table-link';
 export { StatusCell, type StatusCellEntry, type StatusCellProps, StatusClusterCell, type StatusClusterCellItem, type StatusClusterCellProps, DateCell, type DateCellProps, DateMetaCell, type DateMetaCellProps, CurrencyCell, type CurrencyCellProps, AvatarCell, type AvatarCellProps, ResourceCell, type ResourceCellBadge, type ResourceCellLinkProps, type ResourceCellMetadataItem, type ResourceCellProps, } from './partials/cell-renderers';
+export type { ColumnDef } from '@tanstack/react-table';
 export * from './table.types';
 export { defaultDataTableStrings, mergeDataTableStrings } from './table.strings';
 export { handleRowSelectionChange, handleSortingChange, handleColumnVisibilityChange, getRowClassName, getCellClassName, getSelectedRowsData, createRowSelectionCheckbox, createHeaderSelectionCheckbox, addSelectionColumn, } from './table-helpers';

package/dist/components/features/table/pagination.d.ts

@@ -1,5 +1,5 @@
 import { type ServerPaginationProps } from './table.types';
-export declare function Pagination({ pagination, onPageChange, labels, pageQueryKey, }: ServerPaginationProps): import("react").JSX.Element;
+export declare function Pagination({ pagination, onPageChange, labels, pageQueryKey, className, }: ServerPaginationProps): import("react").JSX.Element;
 export declare namespace Pagination {
     var displayName: string;
 }

package/dist/components/features/table/partials/cell-value.d.ts

@@ -63,7 +63,7 @@ export interface CellValueProps extends Omit<CellValueDescriptor, 'className' |
     value?: PrimitiveCellValue;
     /** Which primitive should render the value. Defaults to Value. */
     kind?: CellValueKind;
-    /** Text shown when value is missing. Defaults to '--'. */
+    /** Text shown when value is missing. Defaults to an em dash. */
     fallback?: ReactNode;
     /** Force missing state regardless of value emptiness. */
     missing?: boolean;

package/dist/components/features/table/table-body.d.ts

@@ -1,5 +1,5 @@
 import { type DataTableBodyProps } from './table.types';
-export declare function DataTableBody<TData>({ table, onRowClick, emptyStateMessage, emptyStateAction, cellClassName, rowClassName, stickyFirstColumn, striped, strings, }: DataTableBodyProps<TData>): import("react").JSX.Element;
+export declare function DataTableBody<TData>({ loading, loadingRows, table, onRowClick, emptyStateAction, cellClassName, rowClassName, stickyFirstColumn, striped, strings, }: DataTableBodyProps<TData>): import("react").JSX.Element;
 export declare namespace DataTableBody {
     var displayName: string;
 }

package/dist/components/features/table/table-header.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import { type DataTableHeaderProps } from './table.types';
-export declare function DataTableHeader<TData>({ table, enableResizing, stickyHeader, headerClassName, cellClassName, stickyFirstColumn, columnGroups, headerTransparent, strings, }: DataTableHeaderProps<TData>): React.JSX.Element;
+export declare function DataTableHeader<TData>({ table, enableResizing, stickyHeader, className, cellClassName, stickyFirstColumn, columnGroups, headerTransparent, strings, }: DataTableHeaderProps<TData>): React.JSX.Element;
 export declare namespace DataTableHeader {
     var displayName: string;
 }

package/dist/components/features/table/table-helpers.d.ts

@@ -1,22 +1,47 @@
 import type { SortingState, RowSelectionState, VisibilityState, Table, Row, Updater, ColumnDef } from '@tanstack/react-table';
 import React from 'react';
 import type { DataTableStrings } from './table.types';
+export interface GeneratedColumnOptions<TData> {
+    strings: DataTableStrings;
+    renderActions?: (row: TData) => React.ReactNode;
+}
+export declare function getGeneratedColumnOptions<TData>(table: Table<TData>): GeneratedColumnOptions<TData> | undefined;
 /**
- * Helper function for handling row selection changes with OnChangeFn compatibility
+ * Helper function for handling row selection changes with OnChangeFn compatibility.
+ * Pass the current selection as `currentState` to resolve updater functions
+ * outside React's state updater.
  */
-export declare const handleRowSelectionChange: (updatedSelection: Updater<RowSelectionState>, setInternalState: React.Dispatch<React.SetStateAction<RowSelectionState>>, externalHandler?: (state: RowSelectionState) => void) => void;
+export declare const handleRowSelectionChange: (updatedSelection: Updater<RowSelectionState>, setInternalState: React.Dispatch<React.SetStateAction<RowSelectionState>>, externalHandler?: (state: RowSelectionState) => void, currentState?: RowSelectionState) => void;
 /**
- * Helper function for handling sorting changes with OnChangeFn compatibility
+ * Helper function for handling sorting changes with OnChangeFn compatibility.
+ * Pass the current sorting as `currentState` to resolve updater functions
+ * outside React's state updater.
  */
-export declare const handleSortingChange: (updatedSorting: Updater<SortingState>, setInternalState: React.Dispatch<React.SetStateAction<SortingState>>, externalHandler?: (state: SortingState) => void) => void;
+export declare const handleSortingChange: (updatedSorting: Updater<SortingState>, setInternalState: React.Dispatch<React.SetStateAction<SortingState>>, externalHandler?: (state: SortingState) => void, currentState?: SortingState) => void;
 /**
- * Helper function for handling column visibility changes
+ * Helper function for handling column visibility changes. Pass the current
+ * visibility as `currentState` to resolve updater functions outside React's
+ * state updater.
  */
-export declare const handleColumnVisibilityChange: (updatedVisibility: Updater<VisibilityState>, setInternalState: React.Dispatch<React.SetStateAction<VisibilityState>>, externalHandler?: (state: VisibilityState) => void) => void;
+export declare const handleColumnVisibilityChange: (updatedVisibility: Updater<VisibilityState>, setInternalState: React.Dispatch<React.SetStateAction<VisibilityState>>, externalHandler?: (state: VisibilityState) => void, currentState?: VisibilityState) => void;
 /**
  * Get row class name based on selection state and custom function
  */
 export declare const getRowClassName: <TData>(row: Row<TData>, index: number, rowClassName?: string | ((row: Row<TData>, index: number) => string), isSelected?: boolean) => string;
+/** Which pinned role a column plays when `stickyFirstColumn` is on. */
+export type PinnedColumnRole = 'selection' | 'first';
+/**
+ * The pinned role of the column at `index`, given the visible leaf column ids
+ * in order. The checkbox column and the first data column pin as a pair, so a
+ * selectable table keeps its identifying column in view.
+ */
+export declare function getPinnedColumnRole(columnIds: readonly string[], index: number, stickyFirstColumn?: boolean): PinnedColumnRole | undefined;
+/**
+ * Classes for a pinned cell. The data column sits after the checkbox column
+ * by `--data-table-selection-width`, which DataTable sets on the table area;
+ * only the last pinned column draws the trailing edge.
+ */
+export declare function getPinnedCellClassName(role: PinnedColumnRole | undefined, afterSelection: boolean): string;
 /**
  * Get cell class name including sticky column handling
  */
@@ -26,14 +51,14 @@ export declare const getCellClassName: <TData>(columnId: string, row: Row<TData>
  */
 export declare const getSelectedRowsData: <T extends object>(table: Table<T>) => T[];
 /**
- * Create row selection component for a row
+ * Create row selection component for a row. With `table`, the checkbox is
+ * named by the row's position on screen rather than its index in `data`.
  */
-export declare const createRowSelectionCheckbox: <TData>(row: Row<TData>, strings?: DataTableStrings) => React.JSX.Element;
+export declare const createRowSelectionCheckbox: <TData>(row: Row<TData>, strings?: DataTableStrings, table?: Table<TData>) => React.JSX.Element;
 /**
- * Create header selection checkbox
+ * Create header selection checkbox. A table that allows one selected row has
+ * nothing to select all of, so its header only names the column.
  */
 export declare const createHeaderSelectionCheckbox: <TData>(table: Table<TData>, strings?: DataTableStrings) => React.JSX.Element;
-/**
- * Add selection column to columns
- */
+/** Prepends the checkbox selection column. Explicit strings override table defaults. */
 export declare const addSelectionColumn: <TData, TValue = unknown>(columns: ColumnDef<TData, TValue>[], strings?: DataTableStrings) => ColumnDef<TData, TValue>[];

package/dist/components/features/table/table-region.recipes.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Inline inset for every region that sits above or below a table inside the
+ * same frame: topbar, toolbar, filter bar, selection bar, footer, pagination.
+ *
+ * It is the edge of the table's outer cells, as `base/table/table.css` draws
+ * it: the surface inset (`--surface-x` × `--space-scale`, 24px by default),
+ * and flush inside a padded Card body, where the card already owns the inset.
+ * Sharing the rule keeps a region's text on the first column's edge under any
+ * scoped spacing, and in a flat table composed into a Card.
+ */
+export declare const tableRegionInsetClassName = "px-surface [.card--content:not([data-padding=none])_&:not(.card--content[data-padding=none]_*)]:px-0";

package/dist/components/features/table/table-toolbar.d.ts

@@ -1,5 +1,5 @@
 import { type DataTableToolbarProps } from './table.types';
-export declare function DataTableToolbar<TData>({ table, tableAreaRef, fullscreen, onFullscreenChange, showFullscreenToggle, enableColumnVisibility, labelVisibility, strings, }: DataTableToolbarProps<TData>): import("react").JSX.Element | null;
+export declare function DataTableToolbar<TData>({ table, tableAreaRef, fullscreen, onFullscreenChange, showFullscreenToggle, enableColumnVisibility, labelVisibility, strings, className, }: DataTableToolbarProps<TData>): import("react").JSX.Element | null;
 export declare namespace DataTableToolbar {
     var displayName: string;
 }

package/dist/components/features/table/table.strings.d.ts

@@ -1,5 +1,8 @@
 import { type DataTableStrings, type DataTableStringsOverride } from './table.types';
 export declare const defaultDataTableStrings: {
+    loading: {
+        label: string;
+    };
     emptyState: {
         message: string;
         ariaLabel: string;
@@ -43,6 +46,7 @@ export declare const defaultDataTableStrings: {
         summary: (selected: number, total: number) => string;
         row: (index: number) => string;
         selectAll: string;
+        columnLabel: string;
         clear: string;
         label: string;
     };