@acronis-platform/ui-react 1.0.0 → 2.0.0

package/dist/react.js.map

@@ -1 +1 @@
-{"version":3,"file":"react.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"react.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/src/components/ui/data-table/data-table-bulk-actions-bar.d.ts

@@ -0,0 +1,26 @@
+import { ReactNode } from 'react';
+import { Table } from '@tanstack/react-table';
+interface DataTableBulkActionsBarProps<TData> {
+    table: Table<TData>;
+    /**
+     * Bulk actions offered for the current selection — rendered leading, ahead
+     * of the trailing summary/Deselect control. Wrapped in a native `<fieldset
+     * disabled>` while nothing is selected, so every nested control (a `Button`
+     * renders a plain `<button>`) picks up the disabled state and styling for
+     * free — no per-action wiring needed. Each action reads the selection off
+     * the same `table` instance (`table.getSelectedRowModel().rows`).
+     */
+    children?: ReactNode;
+    /** Builds the trailing selection summary from the selected-row count. */
+    selectedLabel?: (count: number) => string;
+    /** Label of the trailing control that clears the selection. */
+    clearLabel?: string;
+    /**
+     * Trailing summary shown in place of the selection summary while nothing is
+     * selected — e.g. `"25 of 1250 items loaded"`. Omit to render nothing in
+     * that state.
+     */
+    loadedLabel?: ReactNode;
+}
+export declare function DataTableBulkActionsBar<TData>({ table, children, selectedLabel, clearLabel, loadedLabel, }: DataTableBulkActionsBarProps<TData>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/ui/data-table/data-table-column-header.d.ts

@@ -3,6 +3,11 @@ import * as React from 'react';
 interface DataTableColumnHeaderProps<TData, TValue> extends React.ButtonHTMLAttributes<HTMLButtonElement> {
     column: Column<TData, TValue>;
     title: string;
+    /**
+     * Builds the accessible label of the sort toggle from the column title.
+     * Override to localize.
+     */
+    sortLabel?: (title: string) => string;
 }
-export declare function DataTableColumnHeader<TData, TValue>({ column, title, className, ...props }: DataTableColumnHeaderProps<TData, TValue>): import("react/jsx-runtime").JSX.Element;
+export declare function DataTableColumnHeader<TData, TValue>({ column, title, sortLabel, className, ...props }: DataTableColumnHeaderProps<TData, TValue>): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/src/components/ui/data-table/data-table-expand-trigger.d.ts

@@ -3,6 +3,10 @@ import * as React from 'react';
 interface DataTableExpandTriggerProps<TData> extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'children'> {
     /** The row this trigger toggles. */
     row: Row<TData>;
+    /** Accessible name while the row is expanded. Override to localize. */
+    collapseLabel?: string;
+    /** Accessible name while the row is collapsed. Override to localize. */
+    expandLabel?: string;
 }
 export declare const DataTableExpandTrigger: <TData>(props: DataTableExpandTriggerProps<TData> & {
     ref?: React.Ref<HTMLButtonElement>;

package/dist/src/components/ui/data-table/data-table-pagination.d.ts

@@ -3,6 +3,20 @@ interface DataTablePaginationProps<TData> {
     table: Table<TData>;
     /** Page-size options offered in the rows-per-page select. */
     pageSizeOptions?: number[];
+    /** Label of the rows-per-page select (also its accessible name). */
+    rowsPerPageLabel?: string;
+    /** Accessible name of the first-page control. */
+    firstPageLabel?: string;
+    /** Accessible name of the previous-page control. */
+    previousPageLabel?: string;
+    /** Accessible name of the next-page control. */
+    nextPageLabel?: string;
+    /** Accessible name of the last-page control. */
+    lastPageLabel?: string;
+    /** Builds the page indicator from the 1-based page number and page count. */
+    pageLabel?: (page: number, pageCount: number) => string;
+    /** Builds the leading selection summary from the selected and total counts. */
+    summaryLabel?: (selectedRows: number, totalRows: number) => string;
 }
-export declare function DataTablePagination<TData>({ table, pageSizeOptions, }: DataTablePaginationProps<TData>): import("react/jsx-runtime").JSX.Element;
+export declare function DataTablePagination<TData>({ table, pageSizeOptions, rowsPerPageLabel, firstPageLabel, previousPageLabel, nextPageLabel, lastPageLabel, pageLabel, summaryLabel, }: DataTablePaginationProps<TData>): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/src/components/ui/data-table/data-table-selection.d.ts

@@ -0,0 +1,11 @@
+import { Table } from '@tanstack/react-table';
+/**
+ * Whether any row is currently selected — the single threshold that decides
+ * between per-row actions and bulk actions, per the design (Figma 5916-10470
+ * / 5916-10745 / 5916-11716 / 5916-11286 / 5916-11991): a single selected row
+ * already switches to the bulk scope (its own row actions hide, and
+ * `DataTableBulkActionsBar` enables), same as two or more. `TableActionsCell`
+ * takes this as its `bulkSelectionActive` prop, so the threshold doesn't have
+ * to be re-derived per consumer.
+ */
+export declare function isBulkSelectionActive<TData>(table: Table<TData>): boolean;

package/dist/src/components/ui/data-table/data-table-view-options.d.ts

@@ -1,6 +1,7 @@
 import { Table } from '@tanstack/react-table';
-interface DataTableViewOptionsProps<TData> {
+import { TableViewOptionsProps } from '../table';
+interface DataTableViewOptionsProps<TData> extends Pick<TableViewOptionsProps, 'triggerLabel' | 'iconOnly' | 'triggerAriaLabel'> {
     table: Table<TData>;
 }
-export declare function DataTableViewOptions<TData>({ table, }: DataTableViewOptionsProps<TData>): import("react/jsx-runtime").JSX.Element;
+export declare function DataTableViewOptions<TData>({ table, ...triggerProps }: DataTableViewOptionsProps<TData>): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/src/components/ui/data-table/data-table.d.ts

@@ -1,5 +1,5 @@
 import { CSSProperties, ReactNode } from 'react';
-import { Cell, Column, ColumnDef, ColumnSizingState, OnChangeFn, Row, RowData, SortingState, Table as TanstackTable, VisibilityState } from '@tanstack/react-table';
+import { Cell, Column, ColumnDef, ColumnOrderState, ColumnSizingState, OnChangeFn, Row, RowData, RowSelectionState, SortingState, Table as TanstackTable, VisibilityState } from '@tanstack/react-table';
 declare module '@tanstack/react-table' {
     interface ColumnMeta<TData extends RowData, TValue> {
         /** Pin the column to a table edge (sticky while the grid scrolls horizontally). */
@@ -25,6 +25,27 @@ export declare function getResizeKeyboardStep(key: string, currentSize: number,
     min: number;
     max: number;
 }): number | undefined;
+/**
+ * Moves `from` to `to`'s position in a `columnOrder` array (the drop semantics
+ * of the header drag gesture: the dragged column lands where the drop target
+ * sits, pushing it aside). Returns `order` unchanged when either id is absent,
+ * so a drop on a column that isn't part of the order (e.g. one added while the
+ * gesture was in flight) is a no-op rather than a reshuffle.
+ */
+export declare function reorderColumn(order: string[], from: string, to: string): string[];
+/** One line of the header hover tooltip: a capability and the gesture for it. */
+export interface DataTableHeaderHint {
+    /** The capability, rendered in bold (e.g. `Sort column`). */
+    label: string;
+    /** The gesture that triggers it (e.g. `Click`). */
+    action: string;
+}
+/** Copy of the header hover tooltip, one entry per column capability. */
+export interface DataTableHeaderHints {
+    sort: DataTableHeaderHint;
+    reorder: DataTableHeaderHint;
+    resize: DataTableHeaderHint;
+}
 type DataTableDataSourceProps<TData, TValue> = {
     columns: ColumnDef<TData, TValue>[];
     data: TData[];
@@ -44,7 +65,9 @@ type DataTableDataSourceProps<TData, TValue> = {
      * only used to build DataTable's own instance) and the following props
      * no-ops (configure the equivalent directly on the external instance
      * instead): `columnVisibility`, `onColumnVisibilityChange`,
-     * `onColumnSizingChange`, `enableColumnResizing`, `getRowCanExpand`,
+     * `onColumnSizingChange`, `enableColumnResizing`,
+     * `enableColumnReordering`, `columnOrder`, `onColumnOrderChange`,
+     * `getRowCanExpand`,
      * `manualSorting`, `sorting`, `onSortingChange`, `paginationMode`,
      * `onLoadMore`, `loadMoreRootMargin`, `hasNextPage`, `isLoadingMore`.
      * `meta.pin`-driven column pinning is also skipped — pin/unpin the
@@ -77,6 +100,20 @@ interface DataTableOwnProps<TData> {
     enableColumnResizing?: boolean;
     /** Passthrough for the `columnSizing` state so a consumer can persist widths. */
     onColumnSizingChange?: OnChangeFn<ColumnSizingState>;
+    /**
+     * Opt in to column reordering by dragging a header cell onto another one
+     * (native HTML5 drag-and-drop driving TanStack's `columnOrder`). Pinned
+     * columns are excluded — they're anchored to a table edge by definition.
+     * Pointer-only, matching the design: there is no keyboard equivalent yet.
+     */
+    enableColumnReordering?: boolean;
+    /**
+     * Controlled column-order state — pass this (with `onColumnOrderChange`) to
+     * persist or share the order. Uncontrolled (internal state) when omitted.
+     */
+    columnOrder?: ColumnOrderState;
+    /** Passthrough for the `columnOrder` state; pairs with `columnOrder`. */
+    onColumnOrderChange?: OnChangeFn<ColumnOrderState>;
     /**
      * Controlled column-visibility state — pass this (with
      * `onColumnVisibilityChange`) to share one visibility state with an
@@ -86,6 +123,15 @@ interface DataTableOwnProps<TData> {
     columnVisibility?: VisibilityState;
     /** Passthrough for the `columnVisibility` state; pairs with `columnVisibility`. */
     onColumnVisibilityChange?: OnChangeFn<VisibilityState>;
+    /**
+     * Controlled row-selection state — pass this (with `onRowSelectionChange`)
+     * to share one selection state with an external `useReactTable` instance
+     * (e.g. a composed toolbar/bulk-actions bar). Uncontrolled (internal state)
+     * when omitted.
+     */
+    rowSelection?: RowSelectionState;
+    /** Passthrough for the `rowSelection` state; pairs with `rowSelection`. */
+    onRowSelectionChange?: OnChangeFn<RowSelectionState>;
     /**
      * Opt out of client-side sorting — pass already-sorted `data` and drive
      * sorting via `sorting`/`onSortingChange` (e.g. mapped to a server query by
@@ -154,12 +200,51 @@ interface DataTableOwnProps<TData> {
     loadMoreRootMargin?: string;
     /** Whether more rows are available to load. `paginationMode="infinite"` only. */
     hasNextPage?: boolean;
+    /**
+     * Accessible name of a column's resize handle. Override to localize.
+     * `enableColumnResizing` only.
+     */
+    resizeColumnLabel?: string;
+    /**
+     * Text of the default empty-state row. Ignored when `renderEmptyState` is
+     * given. Override to localize.
+     */
+    emptyLabel?: string;
     /**
      * Whether a load is in flight — suppresses further `onLoadMore` calls and
      * renders a trailing loading row. `paginationMode="infinite"` only.
      */
     isLoadingMore?: boolean;
+    /**
+     * Hide the trailing sticky action column — the column-visibility cog in the
+     * header and each row's overflow-actions ellipsis. Shown by default. A
+     * no-op when an external `table` is passed (build the column into that
+     * instance's own `columns` instead).
+     */
+    hideActionColumn?: boolean;
+    /**
+     * Renders the content of a row's overflow-actions menu (e.g. `Edit`/
+     * `Delete` items), opened from the ellipsis trigger in the trailing action
+     * column. Omit to render that row without a trigger — the 48px column is
+     * still reserved. Suppressed (like the trigger itself) while a bulk
+     * selection is active, per `TableActionsCell`.
+     */
+    renderRowActions?: (row: Row<TData>) => ReactNode;
+    /** Accessible name of a row's overflow-actions trigger. Override to localize. */
+    rowActionsLabel?: string;
+    /**
+     * Accessible name of the action column's column-visibility trigger.
+     * Override to localize.
+     */
+    columnSettingsLabel?: string;
+    /**
+     * Copy of the tooltip shown while a header cell is hovered/focused — one
+     * line per capability that column actually has (sort/reorder/resize).
+     * Override (per capability) to localize; a column with no capability shows
+     * no tooltip at all.
+     */
+    headerHints?: Partial<DataTableHeaderHints>;
 }
 export type DataTableProps<TData, TValue = unknown> = DataTableOwnProps<TData> & DataTableDataSourceProps<TData, TValue>;
-export declare function DataTable<TData, TValue = unknown>({ columns, data, table: externalTable, getRowCanExpand, renderExpandedRow, striped, bordered, highlightCurrentRow, skeleton, skeletonRows, enableColumnResizing, onColumnSizingChange, columnVisibility: controlledColumnVisibility, onColumnVisibilityChange, manualSorting, sorting: controlledSorting, onSortingChange, renderRow, renderEmptyState, paginationMode, onLoadMore, loadMoreRootMargin, hasNextPage, isLoadingMore, }: DataTableProps<TData, TValue>): import("react/jsx-runtime").JSX.Element;
+export declare function DataTable<TData, TValue = unknown>({ columns, data, table: externalTable, getRowCanExpand, renderExpandedRow, striped, bordered, highlightCurrentRow, skeleton, skeletonRows, enableColumnResizing, onColumnSizingChange, enableColumnReordering, columnOrder: controlledColumnOrder, onColumnOrderChange, columnVisibility: controlledColumnVisibility, onColumnVisibilityChange, rowSelection: controlledRowSelection, onRowSelectionChange, manualSorting, sorting: controlledSorting, onSortingChange, renderRow, renderEmptyState, paginationMode, onLoadMore, loadMoreRootMargin, hasNextPage, resizeColumnLabel, emptyLabel, isLoadingMore, hideActionColumn, renderRowActions, rowActionsLabel, columnSettingsLabel, headerHints, }: DataTableProps<TData, TValue>): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/src/components/ui/data-table/data-table.docs.d.ts

@@ -14,7 +14,8 @@ export interface DataTableProps {
      * instance as-is. Makes `columns`/`data` unnecessary and the following props
      * no-ops (configure the equivalent on the external instance instead):
      * `columnVisibility`, `onColumnVisibilityChange`, `onColumnSizingChange`,
-     * `enableColumnResizing`, `getRowCanExpand`, `manualSorting`, `sorting`,
+     * `enableColumnResizing`, `enableColumnReordering`, `columnOrder`,
+     * `onColumnOrderChange`, `getRowCanExpand`, `manualSorting`, `sorting`,
      * `onSortingChange`, `paginationMode`, `onLoadMore`, `loadMoreRootMargin`,
      * `hasNextPage`, `isLoadingMore`. `meta.pin`-driven column pinning is also
      * skipped — pin/unpin the caller's own instance via TanStack's `column.pin()`.
@@ -39,8 +40,26 @@ export interface DataTableProps {
      * trailing edge of each resizable header (TanStack's native `columnResizing`).
      */
     enableColumnResizing?: boolean;
+    /**
+     * Accessible name of a column's resize handle (default `'Resize column'`).
+     * `enableColumnResizing` only. Override to localize.
+     */
+    resizeColumnLabel?: string;
     /** Passthrough for the `columnSizing` state so a consumer can persist widths. */
     onColumnSizingChange?: (updater: unknown) => void;
+    /**
+     * Opt in to column reordering by dragging a header cell onto another one
+     * (native HTML5 drag-and-drop driving TanStack's `columnOrder`). Pinned
+     * columns are excluded. Pointer-only — there is no keyboard equivalent yet.
+     */
+    enableColumnReordering?: boolean;
+    /**
+     * Controlled column-order state — pass this (with `onColumnOrderChange`) to
+     * persist or share the order. Uncontrolled (internal state) when omitted.
+     */
+    columnOrder?: string[];
+    /** Passthrough for the `columnOrder` state; pairs with `columnOrder`. */
+    onColumnOrderChange?: (updater: unknown) => void;
     /**
      * Controlled column-visibility state — pass this (with
      * `onColumnVisibilityChange`) to share one visibility state with an external
@@ -49,6 +68,15 @@ export interface DataTableProps {
     columnVisibility?: unknown;
     /** Passthrough for the `columnVisibility` state; pairs with `columnVisibility`. */
     onColumnVisibilityChange?: (updater: unknown) => void;
+    /**
+     * Controlled row-selection state — pass this (with `onRowSelectionChange`) to
+     * share one selection state with an external `useReactTable` instance (e.g. a
+     * composed toolbar/bulk-actions bar). Uncontrolled (internal state) when
+     * omitted.
+     */
+    rowSelection?: unknown;
+    /** Passthrough for the `rowSelection` state; pairs with `rowSelection`. */
+    onRowSelectionChange?: (updater: unknown) => void;
     /**
      * Opt out of client-side sorting — pass already-sorted `data` and drive
      * sorting via `sorting`/`onSortingChange` (e.g. mapped to a server query by
@@ -79,6 +107,11 @@ export interface DataTableProps {
     renderEmptyState?: (context: {
         hasFilters: boolean;
     }) => ReactNode;
+    /**
+     * Text of the default empty-state row (default `'No results.'`). Ignored when
+     * `renderEmptyState` is given. Override to localize.
+     */
+    emptyLabel?: string;
     /**
      * `'page'` (default) keeps today's client-paginated behavior. `'infinite'`
      * omits the paginated row model — `data` is the full accumulated array the
@@ -103,4 +136,31 @@ export interface DataTableProps {
      * renders a trailing loading row. `paginationMode="infinite"` only.
      */
     isLoadingMore?: boolean;
+    /**
+     * Hide the trailing sticky action column — the column-visibility cog in the
+     * header and each row's overflow-actions ellipsis. Shown by default. A
+     * no-op when `table` is passed.
+     */
+    hideActionColumn?: boolean;
+    /**
+     * Renders the content of a row's overflow-actions menu, opened from the
+     * ellipsis trigger in the trailing action column. Omit to render that row
+     * without a trigger — the 48px column is still reserved.
+     */
+    renderRowActions?: (row: unknown) => ReactNode;
+    /** Accessible name of a row's overflow-actions trigger. */
+    rowActionsLabel?: string;
+    /** Accessible name of the action column's column-visibility trigger. */
+    columnSettingsLabel?: string;
+    /**
+     * Copy of the tooltip shown while a header cell is hovered/focused — one
+     * `{ label, action }` line per capability that column actually has. Merged
+     * over the defaults (`sort`: "Sort column"/"Click", `reorder`: "Reorder
+     * column"/"Drag", `resize`: "Resize column"/"Drag border"), so any subset can
+     * be overridden to localize; a column with no capability shows no tooltip.
+     */
+    headerHints?: Partial<Record<'sort' | 'reorder' | 'resize', {
+        label: string;
+        action: string;
+    }>>;
 }

package/dist/src/components/ui/data-table/index.d.ts

@@ -1,4 +1,6 @@
-export { DataTable, type DataTableProps, getCellStyle, getPinnedStyle, getColumnWidth, } from './data-table';
+export { DataTable, type DataTableHeaderHint, type DataTableHeaderHints, type DataTableProps, getCellStyle, getPinnedStyle, getColumnWidth, reorderColumn, } from './data-table';
+export { DataTableBulkActionsBar } from './data-table-bulk-actions-bar';
+export { isBulkSelectionActive } from './data-table-selection';
 export { DataTableColumnHeader } from './data-table-column-header';
 export { DataTableExpandTrigger } from './data-table-expand-trigger';
 export { DataTablePagination } from './data-table-pagination';

package/dist/src/components/ui/stepper/index.d.ts

@@ -0,0 +1 @@
+export { Stepper, type StepperProps } from './stepper';

package/dist/src/components/ui/stepper/stepper.d.ts

@@ -0,0 +1,40 @@
+import * as React from 'react';
+export interface StepperProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * The `StepperItem` elements making up the sequence. Rendered in the wide
+     * (>= 1024px) layout only — the compact layout is a text summary and shows no
+     * items at all.
+     */
+    children?: React.ReactNode;
+    /** 1-based index of the step the user is on, e.g. `3`. Compact layout only. */
+    currentStep: React.ReactNode;
+    /** How many steps there are in total, e.g. `5`. Compact layout only. */
+    totalSteps: React.ReactNode;
+    /** The current step's name. Compact layout only. */
+    current: React.ReactNode;
+    /**
+     * The next step's name. Omit it — on the last step, say — and the whole
+     * "Next: …" line is left out rather than rendered empty. Compact layout only.
+     */
+    next?: React.ReactNode;
+    /**
+     * The word introducing the step counter. A prop, not an inlined literal, so
+     * the string can be translated (see `context/conventions.md` §"Localization —
+     * no hardcoded labels"): this component generates the text itself, unlike the
+     * step names, which the caller supplies.
+     */
+    stepLabel?: string;
+    /** The word joining the current step number to the total. Translatable — see `stepLabel`. */
+    ofLabel?: string;
+    /** The label introducing the next step's name. Translatable — see `stepLabel`. */
+    nextLabel?: string;
+    /**
+     * The punctuation joining the step counter to the current step's name. A prop
+     * for the same reason as `stepLabel`: the component generates it, and not every
+     * locale writes it as `": "` (French, say, spaces before the colon; CJK uses a
+     * full-width one).
+     */
+    separatorLabel?: string;
+}
+declare const Stepper: React.ForwardRefExoticComponent<StepperProps & React.RefAttributes<HTMLDivElement>>;
+export { Stepper };

package/dist/src/components/ui/stepper-item/index.d.ts

@@ -0,0 +1 @@
+export { StepperItem, stepperItemVariants, type StepperItemProps, type StepperItemVariant, type StepperItemState, } from './stepper-item';

package/dist/src/components/ui/stepper-item/stepper-item.d.ts

@@ -0,0 +1,41 @@
+import { useRender } from '@base-ui/react/use-render';
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const stepperItemVariants: (props?: ({
+    variant?: "current" | "completed" | "future" | null | undefined;
+    state?: "active" | "hover" | "idle" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+/** Kept in lockstep with the `cva` axes above. */
+export type StepperItemVariant = NonNullable<VariantProps<typeof stepperItemVariants>['variant']>;
+export type StepperItemState = NonNullable<VariantProps<typeof stepperItemVariants>['state']>;
+export interface StepperItemProps extends React.ComponentPropsWithoutRef<'div'> {
+    /**
+     * The step's structural role in the sequence. Drives the container background
+     * and the label color. Defaults to `current` for prop ergonomics — in a real
+     * sequence every step declares its own.
+     */
+    variant?: StepperItemVariant;
+    /**
+     * Interaction state. Only produces a different look when `variant` is
+     * `completed` (`idle` has no background, `hover` and `active` paint one).
+     * Ignored for `current`, which always renders in its highlighted look, and for
+     * `future`, which always renders disabled and non-interactive.
+     */
+    state?: StepperItemState;
+    /**
+     * The step's marker — required, and entirely the caller's to compose. Pass any
+     * `Avatar` composition (color scheme, initials / icon / image, size overrides);
+     * this component renders it verbatim and never styles it.
+     */
+    avatar: React.ReactElement;
+    /** The step name. */
+    label?: React.ReactNode;
+    /**
+     * Replace the rendered `<div>` with another element or component (Base UI
+     * composition) — e.g. a `<button>`, since a completed step is usually a way
+     * back to an earlier step.
+     */
+    render?: useRender.RenderProp;
+}
+declare const StepperItem: React.ForwardRefExoticComponent<StepperItemProps & React.RefAttributes<HTMLDivElement>>;
+export { StepperItem, stepperItemVariants };

package/dist/src/components/ui/table/index.d.ts

@@ -1,3 +1,3 @@
-export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableCaption, type TableRowProps, type TableHeadProps, type TableCellProps, } from './table';
+export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableSelectCell, TableActionsCell, TableSettingsCell, TableCaption, type TableRowProps, type TableHeadProps, type TableCellProps, type TableSelectCellProps, type TableActionsCellProps, } from './table';
 export { TablePagination, type TablePaginationProps, } from './table-pagination';
 export { TableViewOptions, type TableViewOptionsProps, type TableColumnVisibility, } from './table-view-options';

package/dist/src/components/ui/table/table-pagination.d.ts

@@ -16,6 +16,27 @@ export interface TablePaginationProps extends Omit<React.HTMLAttributes<HTMLDivE
     onPageIndexChange: (pageIndex: number) => void;
     /** Invoked with the next page size. */
     onPageSizeChange: (pageSize: number) => void;
+    /** Label of the rows-per-page select (also its accessible name). */
+    rowsPerPageLabel?: string;
+    /** Accessible name of the first-page control. */
+    firstPageLabel?: string;
+    /** Accessible name of the previous-page control. */
+    previousPageLabel?: string;
+    /** Accessible name of the next-page control. */
+    nextPageLabel?: string;
+    /** Accessible name of the last-page control. */
+    lastPageLabel?: string;
+    /**
+     * Builds the page indicator. Receives the 1-based page number and the total
+     * page count; `pageCount === 0` means there are no pages.
+     */
+    pageLabel?: (page: number, pageCount: number) => string;
+    /**
+     * Builds the leading row summary. Receives the selected-row count (or
+     * `undefined` when selection isn't tracked) and the total row count. Return
+     * `null` for no summary.
+     */
+    summaryLabel?: (selectedRows: number | undefined, totalRows: number) => string | null;
 }
 declare const TablePagination: React.ForwardRefExoticComponent<TablePaginationProps & React.RefAttributes<HTMLDivElement>>;
 export { TablePagination };

package/dist/src/components/ui/table/table-view-options.d.ts

@@ -12,10 +12,17 @@ export interface TableViewOptionsProps {
     columns: TableColumnVisibility[];
     /** Invoked with the column id whose visibility was toggled. */
     onToggle: (id: string) => void;
-    /** Trigger label. Defaults to `View`. */
+    /** Trigger label. Defaults to `View`. Ignored when `iconOnly`. */
     triggerLabel?: React.ReactNode;
+    /**
+     * Render the trigger as a cog-only icon button instead of a labelled
+     * `Button` — the shape that fits the 48px `TableSettingsCell` column.
+     */
+    iconOnly?: boolean;
+    /** Accessible name of the `iconOnly` trigger. Override to localize. */
+    triggerAriaLabel?: string;
 }
-declare function TableViewOptions({ columns, onToggle, triggerLabel, }: TableViewOptionsProps): import("react/jsx-runtime").JSX.Element;
+declare function TableViewOptions({ columns, onToggle, triggerLabel, iconOnly, triggerAriaLabel, }: TableViewOptionsProps): import("react/jsx-runtime").JSX.Element;
 declare namespace TableViewOptions {
     var displayName: string;
 }

package/dist/src/components/ui/table/table.d.ts

@@ -31,5 +31,44 @@ export interface TableCellProps extends React.TdHTMLAttributes<HTMLTableCellElem
     wrap?: boolean;
 }
 declare const TableCell: React.ForwardRefExoticComponent<TableCellProps & React.RefAttributes<HTMLTableCellElement>>;
+export interface TableSelectCellProps extends React.ThHTMLAttributes<HTMLTableCellElement> {
+    /**
+     * Render the select-all cell of the header row (`<th>`) instead of a row's
+     * selection cell (`<td>`).
+     */
+    header?: boolean;
+}
+/**
+ * The row-selection cell (design part `TableCheckbox`) — a fixed 32px column
+ * holding a label-less `Checkbox`. Only the leading padding is applied, matching
+ * the design (16px padding + a 16px box), so the checkbox sits flush against the
+ * first data cell.
+ */
+declare const TableSelectCell: React.ForwardRefExoticComponent<TableSelectCellProps & React.RefAttributes<HTMLTableCellElement>>;
+export interface TableActionsCellProps extends React.TdHTMLAttributes<HTMLTableCellElement> {
+    /**
+     * Suppress this row's actions because a selection is in play — the cell
+     * still reserves its 48px column (so the grid doesn't reflow) but renders no
+     * children and no hover/press tint. Per the design, that means any row is
+     * selected, including exactly one. Pass `isBulkSelectionActive(table)` (from
+     * the data-table part) rather than re-deriving the threshold.
+     */
+    bulkSelectionActive?: boolean;
+}
+/**
+ * The trailing row-actions cell (design part `TableActions`) — a fixed 48px
+ * column, end-aligned, holding the consumer's overflow trigger (e.g. a
+ * `ButtonIcon` with `EllipsisIcon` opening a `DropdownMenu`). The cell itself
+ * carries the hover/press tint and the focus ring, per the design.
+ */
+declare const TableActionsCell: React.ForwardRefExoticComponent<TableActionsCellProps & React.RefAttributes<HTMLTableCellElement>>;
+/**
+ * The trailing header cell holding the column-settings trigger (design part
+ * `TableSettings`) — a fixed 48px column, end-aligned, holding the consumer's
+ * gear trigger (e.g. a `ButtonIcon` with `CogIcon`). Visual states only; what
+ * the trigger opens (a column-visibility menu) is the consumer's choice —
+ * `TableViewOptions` is the ready-made one.
+ */
+declare const TableSettingsCell: React.ForwardRefExoticComponent<React.ThHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
 declare const TableCaption: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableCaptionElement> & React.RefAttributes<HTMLTableCaptionElement>>;
-export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableCaption, };
+export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableSelectCell, TableActionsCell, TableSettingsCell, TableCaption, };

package/dist/src/index.d.ts

@@ -82,6 +82,8 @@ export * from './components/ui/sheet';
 export * from './components/ui/skeleton';
 export * from './components/ui/slider';
 export * from './components/ui/stack';
+export * from './components/ui/stepper';
+export * from './components/ui/stepper-item';
 export * from './components/ui/resizable';
 export * from './components/ui/sidebar-primary';
 export * from './components/ui/sidebar-secondary';