@acronis-platform/ui-react 0.56.0 → 0.56.1

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

@@ -0,0 +1,30 @@
+import { useRender } from '@base-ui/react/use-render';
+import * as React from 'react';
+export interface BreadcrumbProps extends React.ComponentPropsWithoutRef<'nav'> {
+    /**
+     * 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 Breadcrumb: React.ForwardRefExoticComponent<BreadcrumbProps & React.RefAttributes<HTMLElement>>;
+declare const BreadcrumbList: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>, "ref"> & React.RefAttributes<HTMLOListElement>>;
+declare const BreadcrumbItem: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+export interface BreadcrumbLinkProps extends React.ComponentPropsWithoutRef<'a'> {
+    /**
+     * Replace the rendered `<a>` with another element or component (e.g. a
+     * router `Link`) via Base UI composition.
+     */
+    render?: useRender.RenderProp;
+}
+declare const BreadcrumbLink: React.ForwardRefExoticComponent<BreadcrumbLinkProps & React.RefAttributes<HTMLAnchorElement>>;
+declare const BreadcrumbPage: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare const BreadcrumbSeparator: {
+    ({ children, className, ...props }: React.ComponentPropsWithoutRef<"li">): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const BreadcrumbEllipsis: {
+    ({ className, ...props }: React.ComponentPropsWithoutRef<"span">): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { Breadcrumb, BreadcrumbList, BreadcrumbItem, BreadcrumbLink, BreadcrumbPage, BreadcrumbSeparator, BreadcrumbEllipsis, };

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

@@ -0,0 +1 @@
+export { Breadcrumb, BreadcrumbList, BreadcrumbItem, BreadcrumbLink, BreadcrumbPage, BreadcrumbSeparator, BreadcrumbEllipsis, type BreadcrumbProps, type BreadcrumbLinkProps, } from './breadcrumb';

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

@@ -0,0 +1,16 @@
+import { useRender } from '@base-ui/react/use-render';
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const buttonVariants: (props?: ({
+    variant?: "destructive" | "ai" | "default" | "secondary" | "ghost" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    /**
+     * Replace the rendered `<button>` with another element or component
+     * (Base UI composition). Accepts a React element or a render function —
+     * the component's props and class names are merged onto it.
+     */
+    render?: useRender.RenderProp;
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export { Button, buttonVariants };

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

@@ -0,0 +1 @@
+export { Button, buttonVariants, type ButtonProps } from './button';

package/dist/src/components/ui/button-icon/button-icon.d.ts

@@ -0,0 +1,20 @@
+import { useRender } from '@base-ui/react/use-render';
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const buttonIconVariants: (props?: ({
+    variant?: "secondary" | "ghost" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface ButtonIconProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonIconVariants> {
+    /**
+     * Replace the rendered `<button>` with another element or component
+     * (Base UI composition). Accepts a React element or a render function —
+     * the component's props and class names are merged onto it.
+     */
+    render?: useRender.RenderProp;
+}
+/**
+ * Icon-only button. The icon is passed as `children`; provide an `aria-label`
+ * (or `aria-labelledby`) so the control has an accessible name.
+ */
+declare const ButtonIcon: React.ForwardRefExoticComponent<ButtonIconProps & React.RefAttributes<HTMLButtonElement>>;
+export { ButtonIcon, buttonIconVariants };

package/dist/src/components/ui/button-icon/index.d.ts

@@ -0,0 +1 @@
+export { ButtonIcon, buttonIconVariants, type ButtonIconProps, } from './button-icon';

package/dist/src/components/ui/button-menu/button-menu.d.ts

@@ -0,0 +1,29 @@
+import { useRender } from '@base-ui/react/use-render';
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const buttonMenuVariants: (props?: ({
+    variant?: "secondary" | "primary" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface ButtonMenuProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'children'>, VariantProps<typeof buttonMenuVariants> {
+    /**
+     * Whether the associated menu is open. Flips the trailing chevron
+     * (down → up), applies the open (`*-active`) treatment, and reflects
+     * `aria-expanded`. Control this in sync with the menu you trigger.
+     */
+    open?: boolean;
+    /** Label content rendered before the chevron. */
+    children?: React.ReactNode;
+    /**
+     * Replace the rendered `<button>` with another element or component
+     * (Base UI composition). Accepts a React element or a render function —
+     * the component's props and class names are merged onto it.
+     */
+    render?: useRender.RenderProp;
+}
+/**
+ * A button that opens a dropdown menu: a label followed by a chevron that
+ * points up while `open`. Pair it with the menu/popover it controls and keep
+ * the `open` prop in sync.
+ */
+declare const ButtonMenu: React.ForwardRefExoticComponent<ButtonMenuProps & React.RefAttributes<HTMLButtonElement>>;
+export { ButtonMenu, buttonMenuVariants };

package/dist/src/components/ui/button-menu/index.d.ts

@@ -0,0 +1 @@
+export { ButtonMenu, buttonMenuVariants, type ButtonMenuProps, } from './button-menu';

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

@@ -0,0 +1,6 @@
+import { DayButton, DayPicker } from 'react-day-picker';
+import * as React from 'react';
+export type CalendarProps = React.ComponentProps<typeof DayPicker>;
+declare function Calendar({ className, classNames, showOutsideDays, captionLayout, weekStartsOn, formatters, components, ...props }: CalendarProps): import("react/jsx-runtime").JSX.Element;
+declare function CalendarDayButton({ className, day, modifiers, ...props }: React.ComponentProps<typeof DayButton>): import("react/jsx-runtime").JSX.Element;
+export { Calendar, CalendarDayButton };

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

@@ -0,0 +1,21 @@
+/** Props for `Calendar` — a day grid built on `react-day-picker`'s `DayPicker`. */
+export interface CalendarProps {
+    /** Selection mode. Defaults to `single`. */
+    mode?: 'single' | 'multiple' | 'range';
+    /** How many months to render side by side. Defaults to `1`. */
+    numberOfMonths?: number;
+    /** Show days from the previous/next month to fill the grid. Defaults to `true`. */
+    showOutsideDays?: boolean;
+    /** How the month/year caption is rendered. Defaults to `label`. */
+    captionLayout?: 'label' | 'dropdown' | 'dropdown-months' | 'dropdown-years';
+    /** The controlled selection; shape depends on `mode` (`Date`, `Date[]`, or a `{ from, to }` range). */
+    selected?: unknown;
+    /** Called when the selection changes. */
+    onSelect?: (selected: unknown) => void;
+    /** Matcher (or array of matchers) for days that cannot be selected. */
+    disabled?: unknown;
+    /** The month rendered first (uncontrolled). */
+    defaultMonth?: Date;
+    /** Extra classes merged onto the calendar root. */
+    className?: string;
+}

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

@@ -0,0 +1 @@
+export { Calendar, CalendarDayButton, type CalendarProps } from './calendar';

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

@@ -0,0 +1,17 @@
+import { useRender } from '@base-ui/react/use-render';
+import * as React from 'react';
+interface CardPartProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Replace the rendered `<div>` with another element or component (Base UI
+     * composition) — e.g. render `CardTitle` as a heading. The component's props
+     * and class names are merged onto it.
+     */
+    render?: useRender.RenderProp;
+}
+declare const Card: React.ForwardRefExoticComponent<CardPartProps & React.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: React.ForwardRefExoticComponent<CardPartProps & React.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: React.ForwardRefExoticComponent<CardPartProps & React.RefAttributes<HTMLDivElement>>;
+declare const CardDescription: React.ForwardRefExoticComponent<CardPartProps & React.RefAttributes<HTMLDivElement>>;
+declare const CardContent: React.ForwardRefExoticComponent<CardPartProps & React.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: React.ForwardRefExoticComponent<CardPartProps & React.RefAttributes<HTMLDivElement>>;
+export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent, type CardPartProps, };

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

@@ -0,0 +1 @@
+export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent, type CardPartProps, } from './card';

package/dist/src/components/ui/card-filter/card-filter.d.ts

@@ -0,0 +1,27 @@
+import { useRender } from '@base-ui/react/use-render';
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const cardFilterVariants: (props?: ({
+    variant?: "static" | "static-empty" | "clickable" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface CardFilterProps extends Omit<React.HTMLAttributes<HTMLElement>, 'children'>, VariantProps<typeof cardFilterVariants> {
+    /** Caption shown above the value. */
+    label?: React.ReactNode;
+    /** The large value. Ignored for `variant="static-empty"` (shows an em-dash). */
+    value?: React.ReactNode;
+    /** Optional leading icon (16px) rendered before the value. Hidden for `static-empty`. */
+    icon?: React.ReactNode;
+    /**
+     * Replace the rendered element (`<button>` for `clickable`, otherwise `<div>`)
+     * with another element or component (Base UI composition) — e.g. a router link
+     * for a clickable filter. The component's props and class names are merged onto it.
+     */
+    render?: useRender.RenderProp;
+}
+/**
+ * A compact stat/filter card: a label, an optional icon, and a prominent value.
+ * Use `variant="clickable"` for a filter the user can activate (renders a button);
+ * `static` / `static-empty` are presentational.
+ */
+declare const CardFilter: React.ForwardRefExoticComponent<CardFilterProps & React.RefAttributes<HTMLElement>>;
+export { CardFilter, cardFilterVariants };

package/dist/src/components/ui/card-filter/index.d.ts

@@ -0,0 +1 @@
+export { CardFilter, cardFilterVariants, type CardFilterProps } from './card-filter';

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

@@ -0,0 +1,55 @@
+import { LegendPayload } from 'recharts/types/component/DefaultLegendContent';
+import { NameType, Payload, ValueType } from 'recharts/types/component/DefaultTooltipContent';
+import { Props as LegendProps } from 'recharts/types/component/Legend';
+import { TooltipContentProps } from 'recharts/types/component/Tooltip';
+import * as React from 'react';
+import * as RechartsPrimitive from 'recharts';
+declare const THEMES: {
+    readonly light: "";
+    readonly dark: "[data-theme='dark']";
+};
+export type ChartConfig = {
+    [k in string]: {
+        label?: React.ReactNode;
+        icon?: React.ComponentType;
+    } & ({
+        color?: string;
+        theme?: never;
+    } | {
+        color?: never;
+        theme: Record<keyof typeof THEMES, string>;
+    });
+};
+export type ChartTooltipContentProps = Partial<TooltipContentProps<ValueType, NameType>> & {
+    className?: string;
+    hideLabel?: boolean;
+    hideIndicator?: boolean;
+    indicator?: 'line' | 'dot' | 'dashed';
+    nameKey?: string;
+    labelKey?: string;
+    labelFormatter?: (label: TooltipContentProps<number, string>['label'], payload: TooltipContentProps<number, string>['payload']) => React.ReactNode;
+    formatter?: (value: number | string, name: string, item: Payload<number | string, string>, index: number, payload: ReadonlyArray<Payload<number | string, string>>) => React.ReactNode;
+    labelClassName?: string;
+    color?: string;
+};
+export type ChartLegendContentProps = {
+    className?: string;
+    hideIcon?: boolean;
+    verticalAlign?: LegendProps['verticalAlign'];
+    payload?: LegendPayload[];
+    nameKey?: string;
+};
+export interface ChartContainerProps extends React.ComponentProps<'div'> {
+    config: ChartConfig;
+    children: React.ComponentProps<typeof RechartsPrimitive.ResponsiveContainer>['children'];
+}
+declare function ChartContainer({ id, className, children, config, ...props }: ChartContainerProps): import("react/jsx-runtime").JSX.Element;
+declare const ChartStyle: ({ id, config }: {
+    id: string;
+    config: ChartConfig;
+}) => import("react/jsx-runtime").JSX.Element | null;
+declare const ChartTooltip: typeof RechartsPrimitive.Tooltip;
+declare function ChartTooltipContent({ active, payload, label, className, indicator, hideLabel, hideIndicator, labelFormatter, formatter, labelClassName, color, nameKey, labelKey, }: ChartTooltipContentProps): import("react/jsx-runtime").JSX.Element | null;
+declare const ChartLegend: React.MemoExoticComponent<(outsideProps: RechartsPrimitive.LegendProps) => React.ReactPortal | null>;
+declare function ChartLegendContent({ className, hideIcon, payload, verticalAlign, nameKey, }: ChartLegendContentProps): import("react/jsx-runtime").JSX.Element | null;
+export { ChartContainer, ChartTooltip, ChartTooltipContent, ChartLegend, ChartLegendContent, ChartStyle, };

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

@@ -0,0 +1,2 @@
+export { ChartContainer, ChartTooltip, ChartTooltipContent, ChartLegend, ChartLegendContent, ChartStyle, } from './chart';
+export type { ChartConfig, ChartContainerProps, ChartTooltipContentProps, ChartLegendContentProps, } from './chart';

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

@@ -0,0 +1,10 @@
+import { Checkbox as CheckboxPrimitive } from '@base-ui/react/checkbox';
+import * as React from 'react';
+export interface CheckboxProps extends React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root> {
+    /** Optional label rendered beside the box; names the control. */
+    label?: React.ReactNode;
+    /** Optional secondary description rendered under the label. */
+    description?: React.ReactNode;
+}
+declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLElement>>;
+export { Checkbox };

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

@@ -0,0 +1 @@
+export { Checkbox, type CheckboxProps } from './checkbox';

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

@@ -0,0 +1,20 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const chipVariants: (props?: ({
+    variant?: "removable" | "selectable" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface ChipProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof chipVariants> {
+    /** Optional leading icon, rendered at 16px before the label. */
+    icon?: React.ReactNode;
+    /**
+     * `selectable` only — applies the selected (active) styling and exposes the
+     * chip as a pressed toggle (`role="button"` + `aria-pressed`).
+     */
+    selected?: boolean;
+    /** `removable` only — called when the trailing remove (×) button is pressed. */
+    onRemove?: () => void;
+    /** Accessible label for the remove button (`removable`). */
+    removeLabel?: string;
+}
+declare const Chip: React.ForwardRefExoticComponent<ChipProps & React.RefAttributes<HTMLDivElement>>;
+export { Chip, chipVariants };

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

@@ -0,0 +1 @@
+export { Chip, chipVariants, type ChipProps } from './chip';

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

@@ -0,0 +1,5 @@
+import * as React from 'react';
+declare const Collapsible: React.ForwardRefExoticComponent<Omit<import('@base-ui/react').CollapsibleRootProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CollapsibleTrigger: React.ForwardRefExoticComponent<Omit<import('@base-ui/react').CollapsibleTriggerProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const CollapsibleContent: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').CollapsiblePanelProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Collapsible, CollapsibleTrigger, CollapsibleContent };

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

@@ -0,0 +1 @@
+export { Collapsible, CollapsibleTrigger, CollapsibleContent, } from './collapsible';

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

@@ -0,0 +1,28 @@
+import { Combobox as ComboboxPrimitive } from '@base-ui/react/combobox';
+import * as React from 'react';
+declare function Combobox<Value, Multiple extends boolean | undefined = false>(props: ComboboxPrimitive.Root.Props<Value, Multiple>): import("react/jsx-runtime").JSX.Element;
+declare namespace Combobox {
+    var displayName: string;
+}
+export interface ComboboxInputProps extends Omit<React.ComponentPropsWithoutRef<typeof ComboboxPrimitive.Input>, 'className'> {
+    className?: string;
+    /** Wrapper (box) className. */
+    containerClassName?: string;
+    /** Show a clear (✕) button while the field has a value. */
+    clearable?: boolean;
+}
+declare const ComboboxInput: React.ForwardRefExoticComponent<ComboboxInputProps & React.RefAttributes<HTMLInputElement>>;
+export interface ComboboxContentProps extends React.ComponentPropsWithoutRef<typeof ComboboxPrimitive.Popup> {
+    sideOffset?: number;
+    align?: ComboboxPrimitive.Positioner.Props['align'];
+    side?: ComboboxPrimitive.Positioner.Props['side'];
+    /** Container to portal into (e.g. a shadow root, so the popup inherits styles). */
+    portalContainer?: ComboboxPrimitive.Portal.Props['container'];
+}
+declare const ComboboxContent: React.ForwardRefExoticComponent<ComboboxContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const ComboboxList: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').AutocompleteListProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ComboboxItem: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').ComboboxItemProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ComboboxEmpty: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').AutocompleteEmptyProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ComboboxGroup: React.ForwardRefExoticComponent<Omit<import('@base-ui/react').AutocompleteGroupProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ComboboxGroupLabel: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').AutocompleteGroupLabelProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Combobox, ComboboxInput, ComboboxContent, ComboboxList, ComboboxItem, ComboboxEmpty, ComboboxGroup, ComboboxGroupLabel, };

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

@@ -0,0 +1,2 @@
+export { Combobox, ComboboxInput, ComboboxContent, ComboboxList, ComboboxItem, ComboboxEmpty, ComboboxGroup, ComboboxGroupLabel, } from './combobox';
+export type { ComboboxInputProps, ComboboxContentProps, } from './combobox';

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

@@ -0,0 +1,8 @@
+import { Column } from '@tanstack/react-table';
+import * as React from 'react';
+interface DataTableColumnHeaderProps<TData, TValue> extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    column: Column<TData, TValue>;
+    title: string;
+}
+export declare function DataTableColumnHeader<TData, TValue>({ column, title, 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

@@ -0,0 +1,10 @@
+import { Row } from '@tanstack/react-table';
+import * as React from 'react';
+interface DataTableExpandTriggerProps<TData> extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'children'> {
+    /** The row this trigger toggles. */
+    row: Row<TData>;
+}
+export declare const DataTableExpandTrigger: <TData>(props: DataTableExpandTriggerProps<TData> & {
+    ref?: React.Ref<HTMLButtonElement>;
+}) => React.ReactElement | null;
+export {};

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

@@ -0,0 +1,8 @@
+import { Table } from '@tanstack/react-table';
+interface DataTablePaginationProps<TData> {
+    table: Table<TData>;
+    /** Page-size options offered in the rows-per-page select. */
+    pageSizeOptions?: number[];
+}
+export declare function DataTablePagination<TData>({ table, pageSizeOptions, }: DataTablePaginationProps<TData>): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,27 @@
+import { ReactNode } from 'react';
+import { Table } from '@tanstack/react-table';
+interface DataTableToolbarProps<TData> {
+    table: Table<TData>;
+    /**
+     * Rendered as the leading element of the toolbar row, before the search
+     * box — e.g. a tenant/scope `Select` (matches the Figma "FilterSearch"
+     * anatomy, which places a scope switcher ahead of search).
+     */
+    leading?: ReactNode;
+    /** Column id to wire the search box to (client-side text filter). */
+    searchKey?: string;
+    searchPlaceholder?: string;
+    /**
+     * Filter field children rendered inside the `FilterSearchFilters` popover.
+     * Wire each field to a column via `useFilterSearchFilters()` keyed by column
+     * id. When provided, the toolbar renders the filter popover + an applied-filter
+     * chip row below it.
+     */
+    children?: ReactNode;
+    /** Label for the filters trigger button. */
+    filtersLabel?: ReactNode;
+    /** Format an applied-filter chip's label (defaults to `"<id>: <value>"`). */
+    getFilterChipLabel?: (key: string, value: unknown) => ReactNode;
+}
+export declare function DataTableToolbar<TData>({ table, leading, searchKey, searchPlaceholder, children, filtersLabel, getFilterChipLabel, }: DataTableToolbarProps<TData>): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,6 @@
+import { Table } from '@tanstack/react-table';
+interface DataTableViewOptionsProps<TData> {
+    table: Table<TData>;
+}
+export declare function DataTableViewOptions<TData>({ table, }: DataTableViewOptionsProps<TData>): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,62 @@
+import { ReactNode } from 'react';
+import { ColumnDef, ColumnSizingState, OnChangeFn, Row, RowData, 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). */
+        pin?: 'left' | 'right';
+        /**
+         * Let the column's header + cells wrap onto multiple lines (drops the fixed
+         * row height); mirrors the `Table` primitives' `wrap` prop on TableHead/TableCell.
+         */
+        wrap?: boolean;
+    }
+}
+/**
+ * Computes the next column width for an Arrow-key resize step (Shift = larger
+ * step), clamped to `[min, max]` regardless of which bound `currentSize`
+ * started outside of. Returns `undefined` for any other key, so the caller
+ * knows not to `preventDefault()`/resize.
+ */
+export declare function getResizeKeyboardStep(key: string, currentSize: number, { shiftKey, min, max }: {
+    shiftKey: boolean;
+    min: number;
+    max: number;
+}): number | undefined;
+export interface DataTableProps<TData, TValue> {
+    columns: ColumnDef<TData, TValue>[];
+    data: TData[];
+    /** Enables row expansion for rows that return true. Pair with `renderExpandedRow`. */
+    getRowCanExpand?: (row: Row<TData>) => boolean;
+    /**
+     * Renders expanded content for an expanded row. Used together with
+     * `getRowCanExpand`.
+     */
+    renderExpandedRow?: (row: Row<TData>) => ReactNode;
+    /** Alternating row backgrounds. */
+    striped?: boolean;
+    /** Vertical borders between columns (rows already have horizontal borders). */
+    bordered?: boolean;
+    /** Highlight the row the user last clicked (the "current" row). */
+    highlightCurrentRow?: boolean;
+    /** Render placeholder skeleton rows instead of data (loading state). */
+    skeleton?: boolean;
+    /** Number of skeleton rows to render when `skeleton` is set. */
+    skeletonRows?: number;
+    /**
+     * Opt in to interactive column resizing. Renders a drag handle at the trailing
+     * edge of each resizable header cell (TanStack's native `columnResizing`).
+     */
+    enableColumnResizing?: boolean;
+    /** Passthrough for the `columnSizing` state so a consumer can persist widths. */
+    onColumnSizingChange?: OnChangeFn<ColumnSizingState>;
+    /**
+     * Controlled column-visibility state — pass this (with
+     * `onColumnVisibilityChange`) to share one visibility state with an
+     * external `useReactTable` instance (e.g. a composed toolbar). Uncontrolled
+     * (internal state) when omitted.
+     */
+    columnVisibility?: VisibilityState;
+    /** Passthrough for the `columnVisibility` state; pairs with `columnVisibility`. */
+    onColumnVisibilityChange?: OnChangeFn<VisibilityState>;
+}
+export declare function DataTable<TData, TValue>({ columns, data, getRowCanExpand, renderExpandedRow, striped, bordered, highlightCurrentRow, skeleton, skeletonRows, enableColumnResizing, onColumnSizingChange, columnVisibility: controlledColumnVisibility, onColumnVisibilityChange, }: DataTableProps<TData, TValue>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,22 @@
+import { ReactNode } from 'react';
+/** Props for `DataTable`. */
+export interface DataTableProps {
+    /** TanStack column definitions — header/cell renderers and accessors. */
+    columns: unknown[];
+    /** The row data. */
+    data: unknown[];
+    /** Enables row expansion for rows that return true; pair with `renderExpandedRow`. */
+    getRowCanExpand?: (row: unknown) => boolean;
+    /** Renders the detail content for an expanded row. */
+    renderExpandedRow?: (row: unknown) => ReactNode;
+    /** Alternating row backgrounds. */
+    striped?: boolean;
+    /** Vertical borders between columns (rows already have horizontal borders). */
+    bordered?: boolean;
+    /** Highlight the row the user last clicked (the "current" row). */
+    highlightCurrentRow?: boolean;
+    /** Render placeholder skeleton rows instead of data (loading state). */
+    skeleton?: boolean;
+    /** Number of skeleton rows to render when `skeleton` is set (default 5). */
+    skeletonRows?: number;
+}

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

@@ -0,0 +1,6 @@
+export { DataTable, type DataTableProps } from './data-table';
+export { DataTableColumnHeader } from './data-table-column-header';
+export { DataTableExpandTrigger } from './data-table-expand-trigger';
+export { DataTablePagination } from './data-table-pagination';
+export { DataTableToolbar } from './data-table-toolbar';
+export { DataTableViewOptions } from './data-table-view-options';

package/dist/src/components/ui/date-range-picker/__tests__/date-range-picker-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/components/ui/date-range-picker/date-range-picker-utils.d.ts

@@ -0,0 +1,36 @@
+/** A start/end date range. Both ends are optional (a partial range while editing). */
+export interface DateRange {
+    from?: Date;
+    to?: Date;
+}
+/** The date display / parse pattern used by the trigger and the editable fields. */
+export declare const DISPLAY_FORMAT = "MMM d, yyyy";
+/**
+ * Format a date with {@link DISPLAY_FORMAT}, returning `''` for a missing or
+ * invalid `Date`. `date-fns`' `format` throws a `RangeError` on an invalid
+ * `Date` (e.g. `new Date('garbage')`), so the `isValid` guard is load-bearing —
+ * a truthy-but-invalid `Date` must not reach `format`.
+ */
+export declare function formatDate(date: Date | undefined): string;
+/**
+ * Parse a {@link DISPLAY_FORMAT} string into a `Date`, or `undefined` when the
+ * text is empty, partial (mid-type), or not a real calendar date
+ * (e.g. `"Feb 30, 2026"`). The result is normalized to the start of the day so
+ * it round-trips with {@link formatDate} — `date-fns`' `parse` fills the unspecified
+ * time-of-day from its reference date, which would otherwise leave a "now" time
+ * on the value and break equality with the midnight dates the calendar emits.
+ *
+ * NOTE: the pattern is locale-fixed (US-style `MMM d, yyyy`), matching the
+ * `InputDatePicker` trigger. Locale-aware parsing is not yet supported — a
+ * known limitation to revisit once the design tier lands.
+ */
+export declare function parseDate(text: string): Date | undefined;
+/** Structural equality of two ranges by their endpoints' timestamps. */
+export declare function rangesEqual(a: DateRange, b: DateRange): boolean;
+/**
+ * Return a range whose `from` is never after its `to`. When both ends are set
+ * and inverted (e.g. the user typed an end date earlier than the start), the two
+ * are swapped; a partial range (one end unset) is returned unchanged. Used to
+ * keep the calendar highlight and the committed value chronologically ordered.
+ */
+export declare function normalizeRange(range: DateRange): DateRange;

package/dist/src/components/ui/date-range-picker/date-range-picker.d.ts

@@ -0,0 +1,27 @@
+import { DateRange } from './date-range-picker-utils';
+import * as React from 'react';
+export type { DateRange };
+export interface DateRangePickerProps {
+    /** The applied range (controlled). Omit for uncontrolled use with `defaultValue`. */
+    value?: DateRange;
+    /** The initial applied range (uncontrolled) and the target of "Reset to default". */
+    defaultValue?: DateRange;
+    /** Called with the committed range when Apply is pressed. */
+    onValueChange?: (range: DateRange) => void;
+    /** Field label for the trigger. */
+    label?: React.ReactNode;
+    /** Helper text below the trigger. */
+    description?: React.ReactNode;
+    /** Error message below the trigger (switches the trigger to its error treatment). */
+    error?: React.ReactNode;
+    /** Hint shown in the trigger when no range is selected. */
+    placeholder?: React.ReactNode;
+    /** Disables the trigger and prevents opening the popover. */
+    disabled?: boolean;
+    /** Marks the trigger required. */
+    required?: boolean;
+    /** Extra classes merged onto the trigger. */
+    className?: string;
+}
+declare const DateRangePicker: React.ForwardRefExoticComponent<DateRangePickerProps & React.RefAttributes<HTMLButtonElement>>;
+export { DateRangePicker };

package/dist/src/components/ui/date-range-picker/index.d.ts

@@ -0,0 +1 @@
+export { DateRangePicker, type DateRangePickerProps, type DateRange, } from './date-range-picker';

package/dist/src/components/ui/description-list/description-list.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+declare const DescriptionList: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDListElement> & React.RefAttributes<HTMLDListElement>>;
+declare const DescriptionListItem: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const DescriptionListLabel: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLElement> & React.RefAttributes<HTMLElement>>;
+declare const DescriptionListValue: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLElement> & React.RefAttributes<HTMLElement>>;
+declare const DescriptionListValueDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const DescriptionListActions: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export { DescriptionList, DescriptionListItem, DescriptionListLabel, DescriptionListValue, DescriptionListValueDescription, DescriptionListActions, };

package/dist/src/components/ui/description-list/index.d.ts

@@ -0,0 +1 @@
+export { DescriptionList, DescriptionListItem, DescriptionListLabel, DescriptionListValue, DescriptionListValueDescription, DescriptionListActions, } from './description-list';