@acronis-platform/ui-react 0.57.0 → 0.58.0

package/dist/src/components/ui/sidebar-primary/sidebar-primary.d.ts

@@ -0,0 +1,107 @@
+import { useRender } from '@base-ui/react/use-render';
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+/**
+ * Tracks whether `ref`'s element is clipping its own content (`scrollWidth >
+ * clientWidth`) — used to gate a tooltip so it only opens when a truncated
+ * label is actually cut off. Re-measures via `ResizeObserver` (covers the
+ * rail's expand/collapse width transition); `enabled` skips measurement
+ * entirely (e.g. while collapsed, where the label is `sr-only`).
+ */
+declare function useIsOverflowing<T extends Element>(ref: React.RefObject<T | null>, { enabled }: {
+    enabled: boolean;
+}): boolean;
+export interface SidebarPrimaryProps extends React.ComponentPropsWithoutRef<'nav'> {
+    /** Controlled expanded (rail width) state. */
+    expanded?: boolean;
+    /** Uncontrolled initial expanded state. Defaults to `true` (full width). */
+    defaultExpanded?: boolean;
+    /** Fires when the expanded state changes (e.g. a consumer toggle). */
+    onExpandedChange?: (expanded: boolean) => void;
+    /**
+     * Replace the rendered `<nav>` with another element or component
+     * (Base UI composition). Accepts a React element or a render function.
+     */
+    render?: useRender.RenderProp;
+}
+declare const SidebarPrimary: React.ForwardRefExoticComponent<SidebarPrimaryProps & React.RefAttributes<HTMLElement>>;
+export interface SidebarPrimaryHeaderProps extends React.ComponentPropsWithoutRef<'div'> {
+    /**
+     * Logo content shown while the rail is expanded (e.g. a full lockup).
+     * Pairs with `collapsedLogo` to swap distinct graphics per rail state
+     * instead of resizing one. When neither `logo` nor `collapsedLogo` is
+     * given, `children` renders in both states (the original single-slot
+     * behavior).
+     */
+    logo?: React.ReactNode;
+    /**
+     * Logo content shown while the rail is collapsed (e.g. a monogram mark).
+     * Falls back to `logo` when omitted.
+     */
+    collapsedLogo?: React.ReactNode;
+}
+declare const SidebarPrimaryHeader: React.ForwardRefExoticComponent<SidebarPrimaryHeaderProps & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarPrimaryContent: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarPrimaryFooter: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarPrimarySection: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarPrimaryMenu: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+declare const sidebarPrimaryMenuItemVariants: (props?: ({
+    variant?: "selected" | "unselected" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+interface SidebarPrimaryMenuItemBaseProps extends Omit<React.ComponentPropsWithoutRef<'a'>, 'children'>, Omit<VariantProps<typeof sidebarPrimaryMenuItemVariants>, 'variant'> {
+    /** Marks the current route: sets the `selected` variant + `aria-current="page"`. */
+    selected?: boolean;
+    children?: React.ReactNode;
+    /**
+     * Trailing affordance — a `SidebarPrimaryMenuItemExtras` element. Rendered as
+     * a flex sibling of the label (its own `gap` from `_global/container/gap`),
+     * not nested inside the label's truncating span — nesting it there collapses
+     * the row gap and lets `truncate` clip the affordance. Hidden in collapsed/rail
+     * mode regardless of node type — the parent wraps it, so this holds even for
+     * a raw node rather than `SidebarPrimaryMenuItemExtras`.
+     */
+    extras?: React.ReactNode;
+    /**
+     * Replace the rendered `<a>` with another element or component (e.g. a router
+     * `Link` or a `<button>`) via Base UI composition.
+     */
+    render?: useRender.RenderProp;
+}
+export type SidebarPrimaryMenuItemProps = SidebarPrimaryMenuItemBaseProps & ({
+    /** Leading 16px icon (from `@acronis-platform/icons-react`). */
+    icon: Exclude<React.ReactNode, undefined>;
+    noIcon?: never;
+} | {
+    icon?: undefined; /** Explicit opt-out for the rare row with no icon. */
+    noIcon: true;
+});
+declare const SidebarPrimaryMenuItem: React.ForwardRefExoticComponent<SidebarPrimaryMenuItemProps & React.RefAttributes<HTMLAnchorElement>>;
+export interface SidebarPrimaryMenuItemExtrasProps extends React.ComponentPropsWithoutRef<'span'> {
+    /** Which trailing affordance to render. */
+    variant: 'tag' | 'externalLink' | 'shortcut' | 'tag-externalLink';
+    /** Shortcut text (e.g. "⌘H") for the `shortcut` variant. */
+    shortcut?: string;
+    /**
+     * Tag content for the `tag` / `tag-externalLink` variants. Figma constrains
+     * this slot's `Tag` instance to `size="sm"` (no other size is offered on
+     * MenuItemExtras) — always pass a `<Tag variant="info" size="sm">`, never the
+     * default size.
+     */
+    tag?: React.ReactNode;
+}
+declare const SidebarPrimaryMenuItemExtras: React.ForwardRefExoticComponent<SidebarPrimaryMenuItemExtrasProps & React.RefAttributes<HTMLSpanElement>>;
+export interface SidebarPrimaryCollapseTriggerProps extends Omit<React.ComponentPropsWithoutRef<'button'>, 'children'> {
+    /** Leading 16px icon (e.g. a panel-left glyph). Rotates 180° between expanded/collapsed. */
+    icon?: React.ReactNode;
+    children?: React.ReactNode;
+    /**
+     * Trailing affordance — a `SidebarPrimaryMenuItemExtras` element (Figma
+     * shows a `⌘H` shortcut here). Rendered as a flex sibling of the label, same
+     * as `SidebarPrimaryMenuItem`'s `extras` prop.
+     */
+    extras?: React.ReactNode;
+    /** Tooltip text shown when the rail is collapsed. Defaults to `'Expand'`. */
+    expandTooltip?: React.ReactNode;
+}
+declare const SidebarPrimaryCollapseTrigger: React.ForwardRefExoticComponent<SidebarPrimaryCollapseTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+export { SidebarPrimary, SidebarPrimaryHeader, SidebarPrimaryContent, SidebarPrimaryFooter, SidebarPrimarySection, SidebarPrimaryMenu, SidebarPrimaryMenuItem, SidebarPrimaryMenuItemExtras, SidebarPrimaryCollapseTrigger, useIsOverflowing, sidebarPrimaryMenuItemVariants, };

package/dist/src/components/ui/sidebar-secondary/index.d.ts

@@ -0,0 +1 @@
+export { SidebarSecondary, SidebarSecondaryHeader, SidebarSecondaryContent, SidebarSecondaryFooter, SidebarSecondarySection, SidebarSecondarySectionLabel, SidebarSecondaryMenu, SidebarSecondaryMenuItem, SidebarSecondaryMenuItemExtras, SidebarSecondaryCollapseTrigger, sidebarSecondaryMenuItemVariants, type SidebarSecondaryProps, type SidebarSecondaryHeaderProps, type SidebarSecondaryMenuItemProps, type SidebarSecondaryMenuItemExtrasProps, type SidebarSecondaryCollapseTriggerProps, } from './sidebar-secondary';

package/dist/src/components/ui/sidebar-secondary/sidebar-secondary.d.ts

@@ -0,0 +1,115 @@
+import { useRender } from '@base-ui/react/use-render';
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+export interface SidebarSecondaryProps extends React.ComponentPropsWithoutRef<'nav'> {
+    /** Controlled expanded (rail width) state. */
+    expanded?: boolean;
+    /** Uncontrolled initial expanded state. Defaults to `true` (full width). */
+    defaultExpanded?: boolean;
+    /** Fires when the expanded state changes (e.g. a consumer toggle). */
+    onExpandedChange?: (expanded: boolean) => void;
+    /**
+     * Enable the draggable resize edge on the right border.
+     * When `true`, the sidebar can be resized between the expanded-width token
+     * and twice that value.
+     */
+    resizable?: boolean;
+    /** Controlled width in px (only used when `resizable`). */
+    width?: number;
+    /** Fires when the width changes due to a drag interaction. */
+    onWidthChange?: (width: number) => void;
+    /** Accessible label for the resize edge (`role="separator"`). Defaults to `'Resize sidebar'`. */
+    resizeAriaLabel?: string;
+    /** Tooltip content shown when the sidebar is expanded. Pass `null` to hide the tooltip entirely. */
+    resizeTooltipExpanded?: React.ReactNode;
+    /** Tooltip content shown when the sidebar is collapsed. Pass `null` to hide the tooltip entirely. */
+    resizeTooltipCollapsed?: React.ReactNode;
+    /**
+     * Replace the rendered `<nav>` with another element or component
+     * (Base UI composition). Accepts a React element or a render function.
+     */
+    render?: useRender.RenderProp;
+}
+declare const SidebarSecondary: React.ForwardRefExoticComponent<SidebarSecondaryProps & React.RefAttributes<HTMLElement>>;
+export interface SidebarSecondaryHeaderProps extends React.ComponentPropsWithoutRef<'div'> {
+    /** Heading text (or pass as children). */
+    label?: React.ReactNode;
+}
+declare const SidebarSecondaryHeader: React.ForwardRefExoticComponent<SidebarSecondaryHeaderProps & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarSecondaryContent: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export interface SidebarSecondaryCollapsedBreadcrumbProps extends React.ComponentPropsWithoutRef<'div'> {
+    /**
+     * The parent section label (breadcrumbLabel).
+     * Auto-derived from the `SidebarSecondaryHeader` label when omitted.
+     */
+    parentLabel?: React.ReactNode;
+    /**
+     * The current page label (labelCurrentPage).
+     * Auto-derived from the selected `SidebarSecondaryMenuItem` when omitted.
+     */
+    currentLabel?: React.ReactNode;
+    /** Separator between the two; defaults to a 16px ChevronDownIcon. */
+    separator?: React.ReactNode;
+}
+declare const SidebarSecondaryCollapsedBreadcrumb: React.ForwardRefExoticComponent<SidebarSecondaryCollapsedBreadcrumbProps & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarSecondaryFooter: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export interface SidebarSecondarySectionProps extends React.ComponentPropsWithoutRef<'div'> {
+    /**
+     * Make the section a collapsible disclosure: the `SidebarSecondarySectionLabel`
+     * becomes a chevron toggle and the `SidebarSecondaryMenu` becomes its panel.
+     */
+    expandable?: boolean;
+    /** Controlled open state (expandable sections only). */
+    open?: boolean;
+    /** Uncontrolled initial open state (expandable sections only). Defaults to open. */
+    defaultOpen?: boolean;
+    /** Fires with the next open value when an expandable section toggles. */
+    onOpenChange?: (open: boolean) => void;
+}
+declare const SidebarSecondarySection: React.ForwardRefExoticComponent<SidebarSecondarySectionProps & React.RefAttributes<HTMLDivElement>>;
+export interface SidebarSecondarySectionLabelProps extends React.ComponentPropsWithoutRef<'div'> {
+    /** Trailing header actions (e.g. a ghost `ButtonIcon`). Rendered outside the toggle. */
+    actions?: React.ReactNode;
+    /**
+     * A rollup badge (e.g. a `Tag` with an unread count) shown in the header only
+     * when an expandable section is collapsed. Ignored for static sections.
+     */
+    unreadRollup?: React.ReactNode;
+}
+declare const SidebarSecondarySectionLabel: React.ForwardRefExoticComponent<SidebarSecondarySectionLabelProps & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarSecondaryMenu: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+declare const sidebarSecondaryMenuItemVariants: (props?: ({
+    variant?: "selected" | "unselected" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface SidebarSecondaryMenuItemProps extends Omit<React.ComponentPropsWithoutRef<'a'>, 'children'>, Omit<VariantProps<typeof sidebarSecondaryMenuItemVariants>, 'variant'> {
+    /** Marks the current route: sets the `selected` variant + `aria-current="page"`. */
+    selected?: boolean;
+    /** Optional leading 16px icon (`hasIcon` in Figma). */
+    icon?: React.ReactNode;
+    /** Trailing extras (tag, shortcut, external-link icon — `hasExtras` in Figma). */
+    extras?: React.ReactNode;
+    children?: React.ReactNode;
+    /** Replace the rendered `<a>` (e.g. a router `Link` or a `<button>`). */
+    render?: useRender.RenderProp;
+}
+declare const SidebarSecondaryMenuItem: React.ForwardRefExoticComponent<SidebarSecondaryMenuItemProps & React.RefAttributes<HTMLAnchorElement>>;
+export interface SidebarSecondaryMenuItemExtrasProps extends React.ComponentPropsWithoutRef<'span'> {
+    /** Which trailing affordance to render. */
+    variant: 'tag' | 'externalLink' | 'shortcut' | 'tag-externalLink';
+    /** Shortcut text for the `shortcut` variant. */
+    shortcut?: string;
+    /** Tag content for the `tag` / `tag-externalLink` variants. */
+    tag?: React.ReactNode;
+}
+declare const SidebarSecondaryMenuItemExtras: React.ForwardRefExoticComponent<SidebarSecondaryMenuItemExtrasProps & React.RefAttributes<HTMLSpanElement>>;
+export interface SidebarSecondaryCollapseTriggerProps extends Omit<React.ComponentPropsWithoutRef<'button'>, 'children'> {
+    /** Leading 16px icon (e.g. a panel-left glyph). Rotates 180° between expanded/collapsed — same as `SidebarPrimaryCollapseTrigger`. */
+    icon?: React.ReactNode;
+    /** Tooltip text shown when the sidebar is collapsed. Defaults to `'Expand'`. */
+    expandTooltip?: React.ReactNode;
+    /** Trailing extras (e.g. a keyboard shortcut hint), same slot as `SidebarSecondaryMenuItem`. */
+    extras?: React.ReactNode;
+    children?: React.ReactNode;
+}
+declare const SidebarSecondaryCollapseTrigger: React.ForwardRefExoticComponent<SidebarSecondaryCollapseTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+export { SidebarSecondary, SidebarSecondaryHeader, SidebarSecondaryContent, SidebarSecondaryCollapsedBreadcrumb, SidebarSecondaryFooter, SidebarSecondarySection, SidebarSecondarySectionLabel, SidebarSecondaryMenu, SidebarSecondaryMenuItem, SidebarSecondaryMenuItemExtras, SidebarSecondaryCollapseTrigger, sidebarSecondaryMenuItemVariants, };

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

@@ -0,0 +1 @@
+export { Skeleton, type SkeletonProps } from './skeleton';

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

@@ -0,0 +1,4 @@
+import * as React from 'react';
+export type SkeletonProps = React.HTMLAttributes<HTMLDivElement>;
+declare const Skeleton: React.ForwardRefExoticComponent<SkeletonProps & React.RefAttributes<HTMLDivElement>>;
+export { Skeleton };

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

@@ -0,0 +1 @@
+export { Slider, type SliderProps } from './slider';

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

@@ -0,0 +1,7 @@
+import { Slider as SliderPrimitive } from '@base-ui/react/slider';
+import * as React from 'react';
+export type SliderProps = React.ComponentPropsWithoutRef<typeof SliderPrimitive.Root>;
+declare const Slider: React.ForwardRefExoticComponent<Omit<SliderPrimitive.Root.Props<number | readonly number[]> & {
+    ref?: React.Ref<HTMLDivElement> | undefined;
+}, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Slider };

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

@@ -0,0 +1 @@
+export { Spinner, spinnerVariants, type SpinnerProps } from './spinner';

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

@@ -0,0 +1,9 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const spinnerVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | "xl" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface SpinnerProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof spinnerVariants> {
+}
+declare const Spinner: React.ForwardRefExoticComponent<SpinnerProps & React.RefAttributes<HTMLDivElement>>;
+export { Spinner, spinnerVariants };

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

@@ -0,0 +1 @@
+export { Stack, stackVariants, type StackProps } from './stack';

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

@@ -0,0 +1,13 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const stackVariants: (props?: ({
+    direction?: "horizontal" | "vertical" | null | undefined;
+    gap?: "none" | "sm" | "md" | "lg" | "xl" | "xs" | null | undefined;
+    align?: "center" | "end" | "start" | "stretch" | null | undefined;
+    justify?: "center" | "end" | "start" | "between" | null | undefined;
+    wrap?: boolean | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface StackProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof stackVariants> {
+}
+declare const Stack: React.ForwardRefExoticComponent<StackProps & React.RefAttributes<HTMLDivElement>>;
+export { Stack, stackVariants };

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

@@ -0,0 +1 @@
+export { Switch, type SwitchProps } from './switch';

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

@@ -0,0 +1,8 @@
+import { Switch as SwitchPrimitive } from '@base-ui/react/switch';
+import * as React from 'react';
+export interface SwitchProps extends React.ComponentPropsWithoutRef<typeof SwitchPrimitive.Root> {
+    /** Optional label rendered beside the toggle; names the control. */
+    label?: React.ReactNode;
+}
+declare const Switch: React.ForwardRefExoticComponent<SwitchProps & React.RefAttributes<HTMLElement>>;
+export { Switch };

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

@@ -0,0 +1,3 @@
+export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableCaption, type TableRowProps, type TableHeadProps, type TableCellProps, } 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

@@ -0,0 +1,21 @@
+import * as React from 'react';
+export interface TablePaginationProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Zero-based index of the current page. */
+    pageIndex: number;
+    /** Total number of pages. */
+    pageCount: number;
+    /** Number of rows shown per page. */
+    pageSize: number;
+    /** Page-size options offered in the rows-per-page select. */
+    pageSizeOptions?: number[];
+    /** Total number of rows across all pages (drives the summary text). */
+    totalRows?: number;
+    /** Number of currently selected rows (drives the selection summary text). */
+    selectedRows?: number;
+    /** Invoked with the next zero-based page index. */
+    onPageIndexChange: (pageIndex: number) => void;
+    /** Invoked with the next page size. */
+    onPageSizeChange: (pageSize: number) => void;
+}
+declare const TablePagination: React.ForwardRefExoticComponent<TablePaginationProps & React.RefAttributes<HTMLDivElement>>;
+export { TablePagination };

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

@@ -0,0 +1,22 @@
+import * as React from 'react';
+export interface TableColumnVisibility {
+    /** Stable column identifier. */
+    id: string;
+    /** Human-readable label shown in the menu. */
+    label: string;
+    /** Whether the column is currently hidden. */
+    hidden: boolean;
+}
+export interface TableViewOptionsProps {
+    /** The toggleable columns and their current visibility. */
+    columns: TableColumnVisibility[];
+    /** Invoked with the column id whose visibility was toggled. */
+    onToggle: (id: string) => void;
+    /** Trigger label. Defaults to `View`. */
+    triggerLabel?: React.ReactNode;
+}
+declare function TableViewOptions({ columns, onToggle, triggerLabel, }: TableViewOptionsProps): import("react/jsx-runtime").JSX.Element;
+declare namespace TableViewOptions {
+    var displayName: string;
+}
+export { TableViewOptions };

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

@@ -0,0 +1,35 @@
+import * as React from 'react';
+declare const Table: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableElement> & React.RefAttributes<HTMLTableElement>>;
+declare const TableHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+export interface TableRowProps extends React.HTMLAttributes<HTMLTableRowElement> {
+    /** Mark the row as selected — applies the active row token + `data-state`. */
+    selected?: boolean;
+}
+declare const TableRow: React.ForwardRefExoticComponent<TableRowProps & React.RefAttributes<HTMLTableRowElement>>;
+type SortDirection = 'asc' | 'desc' | false;
+export interface TableHeadProps extends React.ThHTMLAttributes<HTMLTableCellElement> {
+    /** Render the column as sortable — adds a sort affordance and `aria-sort`. */
+    sortable?: boolean;
+    /** Current sort direction for this column (`false` = sortable but unsorted). */
+    sortDirection?: SortDirection;
+    /** Invoked when the user activates a sortable header (click / Enter / Space). */
+    onSort?: () => void;
+    /**
+     * Allow the header to wrap onto multiple lines (`whitespace-normal`) and drop
+     * the fixed row height so the cell grows to fit its content.
+     */
+    wrap?: boolean;
+}
+declare const TableHead: React.ForwardRefExoticComponent<TableHeadProps & React.RefAttributes<HTMLTableCellElement>>;
+export interface TableCellProps extends React.TdHTMLAttributes<HTMLTableCellElement> {
+    /**
+     * Allow the cell to wrap onto multiple lines (`whitespace-normal`) and drop
+     * the fixed row height so the row grows to fit its content.
+     */
+    wrap?: boolean;
+}
+declare const TableCell: React.ForwardRefExoticComponent<TableCellProps & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCaption: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableCaptionElement> & React.RefAttributes<HTMLTableCaptionElement>>;
+export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableCaption, };

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

@@ -0,0 +1 @@
+export { Tabs, TabsList, TabsTrigger, TabsContent } from './tabs';

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

@@ -0,0 +1,6 @@
+import * as React from 'react';
+declare const Tabs: React.ForwardRefExoticComponent<Omit<import('@base-ui/react').TabsRootProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const TabsList: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').TabsListProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').TabsTabProps, "ref"> & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const TabsContent: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').TabsPanelProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tabs, TabsList, TabsTrigger, TabsContent };

package/dist/src/components/ui/tabs/tabs.docs.d.ts

@@ -0,0 +1,25 @@
+import type * as React from 'react';
+/** Props for `Tabs` (the root). */
+export interface TabsProps {
+    /** Controlled selected-tab value. Pair with `onValueChange`. */
+    value?: string | number;
+    /** Initially selected tab value (uncontrolled). */
+    defaultValue?: string | number;
+    /** Fired with the newly selected tab value. */
+    onValueChange?: (value: string | number, eventDetails: unknown) => void;
+    /** Layout and arrow-key navigation orientation. Defaults to `horizontal`. */
+    orientation?: 'horizontal' | 'vertical';
+    /** A `TabsList` of `TabsTrigger`s plus matching `TabsContent` panels. */
+    children?: React.ReactNode;
+}
+/** Props shared by `TabsTrigger` and `TabsContent`. */
+export interface TabsPartProps {
+    /**
+     * Identifies the tab: a `TabsTrigger` and the `TabsContent` it controls share
+     * the same `value`.
+     */
+    value: string | number;
+    /** On `TabsTrigger` — disables selecting that tab. */
+    disabled?: boolean;
+    children?: React.ReactNode;
+}

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

@@ -0,0 +1 @@
+export { Tag, tagVariants, type TagProps } from './tag';

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

@@ -0,0 +1,12 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const tagVariants: (props?: ({
+    variant?: "info" | "success" | "warning" | "critical" | "ai" | "neutral" | "danger" | null | undefined;
+    size?: "default" | "sm" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface TagProps extends React.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof tagVariants> {
+    /** Optional leading icon, rendered at 16px before the label. */
+    icon?: React.ReactNode;
+}
+declare const Tag: React.ForwardRefExoticComponent<TagProps & React.RefAttributes<HTMLSpanElement>>;
+export { Tag, tagVariants };

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

@@ -0,0 +1 @@
+export { Timeline, TimelineItem, type TimelineProps, type TimelineItemProps, type TimelineStatus, } from './timeline';

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

@@ -0,0 +1,41 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const timelineVariants: (props?: ({
+    size?: "small" | "medium" | null | undefined;
+    density?: "compact" | "default" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface TimelineProps extends React.ComponentProps<'ol'>, VariantProps<typeof timelineVariants> {
+    /**
+     * `Timeline.Item`s — pass them as direct children (the connector auto-hides on
+     * the last one). Grouping/headings aren't supported as intervening children.
+     */
+    children?: React.ReactNode;
+}
+export type TimelineStatus = 'neutral' | 'info' | 'success' | 'warning' | 'danger' | 'critical';
+export interface TimelineItemProps extends Omit<React.ComponentProps<'li'>, 'title'> {
+    /** Event time — pass a `<time dateTime>` for an accessible, machine-readable stamp. */
+    timestamp?: React.ReactNode;
+    /** Event title (the primary line). */
+    title: React.ReactNode;
+    /** Optional secondary description. */
+    description?: React.ReactNode;
+    /** Semantic status — tints the marker (a subtle cue, never large blocks of text). */
+    status?: TimelineStatus;
+    /** Icon shown in a status-tinted marker badge instead of the plain dot. */
+    icon?: React.ReactNode;
+    /** Metadata slot under the description — e.g. `Tag`s. */
+    metadata?: React.ReactNode;
+    /** Actions slot — e.g. a `Link` or `ButtonMenu`. */
+    actions?: React.ReactNode;
+    /** Emphasize this item as the current one (a ringed marker). */
+    current?: boolean;
+    /** Dim a non-applicable / inactive item. */
+    disabled?: boolean;
+    /** Expandable detail composed by the caller — e.g. an `Accordion`. */
+    children?: React.ReactNode;
+}
+declare const TimelineItem: React.ForwardRefExoticComponent<Omit<TimelineItemProps, "ref"> & React.RefAttributes<HTMLLIElement>>;
+declare const Timeline: React.ForwardRefExoticComponent<Omit<TimelineProps, "ref"> & React.RefAttributes<HTMLOListElement>> & {
+    Item: React.ForwardRefExoticComponent<Omit<TimelineItemProps, "ref"> & React.RefAttributes<HTMLLIElement>>;
+};
+export { Timeline, TimelineItem };

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

@@ -0,0 +1 @@
+export { toast, Toaster, type ToasterProps, type ToastType, type ToastOptions, } from './toast';

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

@@ -0,0 +1,48 @@
+import { Toast as ToastPrimitive } from '@base-ui/react/toast';
+import * as React from 'react';
+export type ToastType = 'success' | 'info' | 'warning' | 'error' | 'loading';
+export interface ToastOptions {
+    /** Secondary line under the title. */
+    description?: React.ReactNode;
+    /** Auto-dismiss delay in ms; `0` keeps the toast until dismissed. */
+    timeout?: number;
+    /** A single inline action button (e.g. Undo). */
+    action?: {
+        label: React.ReactNode;
+        onClick?: () => void;
+    };
+    /** Stable id — re-adding with the same id updates the toast in place. */
+    id?: string;
+}
+/**
+ * Imperative toast API. `toast(title, options)` shows a neutral toast;
+ * `toast.success` / `info` / `warning` / `error` / `loading` set the variant.
+ * `toast.dismiss(id?)` closes one (or all) and `toast.promise` ties a toast to a
+ * promise's lifecycle.
+ */
+declare const toast: ((title: React.ReactNode, options?: ToastOptions) => string) & {
+    success: (title: React.ReactNode, options?: ToastOptions) => string;
+    info: (title: React.ReactNode, options?: ToastOptions) => string;
+    warning: (title: React.ReactNode, options?: ToastOptions) => string;
+    error: (title: React.ReactNode, options?: ToastOptions) => string;
+    loading: (title: React.ReactNode, options?: ToastOptions) => string;
+    dismiss: (id?: string) => void;
+    promise: <Value, T extends any = any>(promiseValue: Promise<Value>, options: import('@base-ui/react').ToastManagerPromiseOptions<Value, T>) => Promise<Value>;
+};
+export interface ToasterProps {
+    /** Default auto-dismiss delay in ms for toasts that don't set one. */
+    timeout?: number;
+    /** Max toasts shown at once; the oldest is dropped past the limit. */
+    limit?: number;
+    /**
+     * Portal container for the toast stack. Pass a shadow-root mount for
+     * isolated-style previews (the docs demos do this via `useShadowMount`).
+     */
+    portalContainer?: ToastPrimitive.Portal.Props['container'];
+}
+/**
+ * The toast region. Render once near the app root; it portals a bottom-right
+ * stack and renders every queued toast. Trigger toasts with the `toast` API.
+ */
+declare function Toaster({ timeout, limit, portalContainer }: ToasterProps): import("react/jsx-runtime").JSX.Element;
+export { toast, Toaster };

package/dist/src/components/ui/toast/toast.docs.d.ts

@@ -0,0 +1,12 @@
+/** Props for `<Toaster>` — the toast region rendered once near the app root. */
+export interface ToasterProps {
+    /** Default auto-dismiss delay in ms for toasts that don't set one (default 5000). */
+    timeout?: number;
+    /** Max toasts shown at once; the oldest is dropped past the limit (default 3). */
+    limit?: number;
+    /**
+     * Portal container for the toast stack. Pass a shadow-root mount for
+     * isolated-style previews (the docs demos do this via `useShadowMount`).
+     */
+    portalContainer?: HTMLElement | null;
+}

package/dist/src/components/ui/toggle-group/index.d.ts

@@ -0,0 +1 @@
+export { Toggle, ToggleGroup, ToggleGroupItem } from './toggle-group';

package/dist/src/components/ui/toggle-group/toggle-group.d.ts

@@ -0,0 +1,7 @@
+import { Toggle as TogglePrimitive } from '@base-ui/react/toggle';
+import { ToggleGroup as ToggleGroupPrimitive } from '@base-ui/react/toggle-group';
+import * as React from 'react';
+declare const Toggle: React.ForwardRefExoticComponent<Omit<TogglePrimitive.Props<string> & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const ToggleGroup: React.ForwardRefExoticComponent<Omit<ToggleGroupPrimitive.Props<string> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ToggleGroupItem: React.ForwardRefExoticComponent<Omit<TogglePrimitive.Props<string> & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { Toggle, ToggleGroup, ToggleGroupItem };

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

@@ -0,0 +1 @@
+export { Toolbar, ToolbarActions, ToolbarActionList, type ToolbarProps, type ToolbarActionsProps, type ToolbarActionListProps, type ToolbarActionListItem, } from './toolbar';

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

@@ -0,0 +1,23 @@
+import * as React from 'react';
+export type ToolbarProps = React.ComponentPropsWithoutRef<'fieldset'>;
+declare const Toolbar: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.FieldsetHTMLAttributes<HTMLFieldSetElement>, HTMLFieldSetElement>, "ref"> & React.RefAttributes<HTMLFieldSetElement>>;
+export type ToolbarActionsProps = React.ComponentPropsWithoutRef<'div'>;
+declare const ToolbarActions: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export declare function computeVisibleActionCount(itemWidths: number[], moreWidth: number, gap: number, availableWidth: number): number;
+export declare function measureNaturalWidth(el: Element): number;
+export interface ToolbarActionListItem {
+    /** Stable identity — used as the React key in both the row and the overflow menu. */
+    key: string;
+    /** Rendered as the visible ghost Button's label, and the overflow menu item's label. */
+    label: React.ReactNode;
+    onSelect?: () => void;
+    disabled?: boolean;
+}
+export interface ToolbarActionListProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'children'> {
+    /** Ordered list of actions; trailing ones collapse into "More actions" first. */
+    actions: ToolbarActionListItem[];
+    /** Label for the overflow trigger. */
+    moreActionsLabel?: React.ReactNode;
+}
+declare const ToolbarActionList: React.ForwardRefExoticComponent<ToolbarActionListProps & React.RefAttributes<HTMLDivElement>>;
+export { Toolbar, ToolbarActions, ToolbarActionList };

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

@@ -0,0 +1 @@
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider, } from './tooltip';

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

@@ -0,0 +1,21 @@
+import { Tooltip as TooltipPrimitive } from '@base-ui/react/tooltip';
+import * as React from 'react';
+declare function TooltipProvider(props: React.ComponentProps<typeof TooltipPrimitive.Provider>): import("react/jsx-runtime").JSX.Element;
+declare const Tooltip: <Payload>(props: TooltipPrimitive.Root.Props<Payload>) => import("react/jsx-runtime").JSX.Element;
+declare const TooltipTrigger: TooltipPrimitive.Trigger;
+declare const TooltipContent: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').TooltipPopupProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    sideOffset?: number;
+    side?: TooltipPrimitive.Positioner.Props["side"];
+    align?: TooltipPrimitive.Positioner.Props["align"];
+    /**
+     * Override what the popup is positioned against — defaults to the
+     * `TooltipTrigger` element. Useful when the hover/focus trigger is
+     * narrower than the element the tooltip should visually align to (e.g. a
+     * truncating label inside a full-width row, where the tooltip should
+     * anchor to the row's edge, not the label's).
+     */
+    anchor?: TooltipPrimitive.Positioner.Props["anchor"];
+    portalContainer?: TooltipPrimitive.Portal.Props["container"];
+    keepMounted?: TooltipPrimitive.Portal.Props["keepMounted"];
+} & React.RefAttributes<HTMLDivElement>>;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

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

@@ -0,0 +1 @@
+export { Treemap, type TreemapProps } from './treemap';