@acronis-platform/ui-react 0.57.0 → 0.58.0

package/dist/src/components/ui/confidence-cone/confidence-cone.d.ts

@@ -0,0 +1,79 @@
+import { ChartTooltip, ChartConfig } from '../chart';
+import * as React from 'react';
+/**
+ * Drop the synthetic cone-band range series from a recharts tooltip/legend
+ * payload, keeping the real actual/forecast series (and their order). Applied to
+ * both the default tooltip and any caller-supplied `tooltipContent`, so the
+ * `__cone` band never surfaces regardless of which path renders.
+ */
+export declare function dropConeBand<T extends {
+    dataKey?: unknown;
+}>(payload: readonly T[] | undefined): T[] | undefined;
+/**
+ * Wrap a caller-supplied `tooltipContent` so the synthetic cone band is stripped
+ * from the payload before it renders, while preserving recharts' own mount
+ * semantics — a function is mounted via `createElement` (its own component
+ * identity + hook state), an element via `cloneElement`. This mirrors what the
+ * pass-through charts get by handing `content` straight to recharts, so a
+ * function-form tooltip keeps its state across re-renders here too. The returned
+ * component is a stable content type (memoize it on `tooltipContent`).
+ */
+type TooltipContentType = NonNullable<React.ComponentProps<typeof ChartTooltip>['content']>;
+type TooltipContentFn = Extract<TooltipContentType, (...args: never[]) => unknown>;
+type TooltipRenderProps = Parameters<TooltipContentFn>[0];
+export declare function createConeTooltip(tooltipContent: TooltipContentType): (props: TooltipRenderProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | React.FunctionComponentElement<import('recharts').TooltipContentProps<import('recharts').TooltipValueType, import('recharts/types/component/DefaultTooltipContent').NameType>>;
+export interface ConfidenceConeProps extends Omit<React.ComponentProps<'div'>, 'children'> {
+    /**
+     * Row-per-point data — the shared x dimension plus the actual / forecast /
+     * bound fields. Rows are naturally sparse (a point has either an actual or a
+     * forecast + bounds), so missing fields are allowed. Avoid a field named
+     * `__cone` — it's reserved for the internal prediction-band series.
+     */
+    data: ReadonlyArray<Record<string, string | number | null | undefined>>;
+    /**
+     * Per-series map of `label` / `color` for the actual + forecast lines
+     * (imported from the shared `Chart` primitives). Colors are caller-supplied —
+     * reference an existing semantic `--ui-*` token; there is no chart palette tier
+     * yet. The cone band and the forecast line both reuse the actual series'
+     * color — actual and forecast differ by line style, not hue.
+     */
+    config: ChartConfig;
+    /** Category / time axis key (the shared dimension across rows). */
+    xKey: string;
+    /** Field for the known/actual values — drawn as a solid line with a filled area. */
+    actualKey: string;
+    /** Field for the projected values — drawn as a dashed line. */
+    forecastKey: string;
+    /** Field for the cone's lower bound. */
+    lowerKey: string;
+    /** Field for the cone's upper bound. */
+    upperKey: string;
+    /** Title rendered beneath the horizontal (X) axis. */
+    xAxisLabel?: string;
+    /** Title rendered beside the vertical (Y) axis (rotated). */
+    yAxisLabel?: string;
+    /** Unit suffix appended to Y-axis tick values (recharts `unit`; the X axis is categorical). */
+    yUnit?: string;
+    /** Stroke width of the actual + forecast lines. */
+    strokeWidth?: number;
+    /**
+     * Set off the forecast period from the actuals with a dashed divider at the
+     * hand-off point (the first row with a forecast value) and a subtle shaded
+     * band over the forecast region.
+     */
+    showForecastRegion?: boolean;
+    showGrid?: boolean;
+    showTooltip?: boolean;
+    showLegend?: boolean;
+    /**
+     * Replace the default tooltip. Pass a configured `ChartTooltipContent`
+     * (imported from this library) — e.g. with a `formatter` / `labelFormatter` —
+     * to customize the tooltip without composing recharts yourself. The synthetic
+     * cone band is filtered out of the payload before your tooltip sees it, so a
+     * `__cone` item never reaches your formatter. Ignored when `showTooltip` is
+     * false.
+     */
+    tooltipContent?: React.ComponentProps<typeof ChartTooltip>['content'];
+}
+declare const ConfidenceCone: React.ForwardRefExoticComponent<Omit<ConfidenceConeProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { ConfidenceCone };

package/dist/src/components/ui/confidence-cone/index.d.ts

@@ -0,0 +1 @@
+export { ConfidenceCone, type ConfidenceConeProps } from './confidence-cone';

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,165 @@
+import { CSSProperties, ReactNode } from 'react';
+import { Cell, Column, ColumnDef, ColumnSizingState, OnChangeFn, Row, RowData, 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). */
+        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;
+    }
+}
+export declare function getPinnedStyle<TData>(column: Column<TData, unknown>): CSSProperties | undefined;
+export declare function getColumnWidth<TData>(column: Column<TData, unknown>, enableColumnResizing: boolean): number | undefined;
+export declare function getCellStyle<TData>(cell: Cell<TData, unknown>, enableColumnResizing: boolean): CSSProperties | undefined;
+/**
+ * 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;
+type DataTableDataSourceProps<TData, TValue> = {
+    columns: ColumnDef<TData, TValue>[];
+    data: TData[];
+    /**
+     * Also drive an externally-built TanStack `table` instance (e.g. a
+     * composed toolbar/pagination) from the same state as this DataTable.
+     */
+    table?: TanstackTable<TData>;
+} | {
+    columns?: ColumnDef<TData, TValue>[];
+    data?: TData[];
+    /**
+     * Render from an externally-built TanStack `table` instance instead of
+     * DataTable's own — DataTable then owns no state and renders the caller's
+     * instance as-is (sorting, filtering, pagination, row models, etc. are all
+     * configured on that instance). Makes `columns`/`data` unnecessary (they're
+     * 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`,
+     * `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()` directly.
+     */
+    table: TanstackTable<TData>;
+};
+interface DataTableOwnProps<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>;
+    /**
+     * Opt out of client-side sorting — pass already-sorted `data` and drive
+     * sorting via `sorting`/`onSortingChange` (e.g. mapped to a server query by
+     * the caller). Mapping sort state to a query and refetching stays the
+     * caller's job; DataTable only skips its own comparator.
+     */
+    manualSorting?: boolean;
+    /**
+     * Controlled sorting state — pass this (with `onSortingChange`) to drive
+     * sorting externally. Uncontrolled (internal state) when omitted.
+     */
+    sorting?: SortingState;
+    /** Passthrough for the `sorting` state; pairs with `sorting`. */
+    onSortingChange?: OnChangeFn<SortingState>;
+    /**
+     * Renders a full row, bypassing DataTable's default per-cell `flexRender`
+     * path entirely (no `<TableRow>`/cell-styling/pinning of DataTable's own).
+     * Use to swap in a custom, independently memoizable row component. The
+     * caller owns the row's markup and equality semantics — reuse the exported
+     * `getCellStyle`/`getPinnedStyle`/`getColumnWidth` helpers to match
+     * DataTable's default cell styling if desired.
+     *
+     * Also bypasses DataTable's `renderExpandedRow` handling — a row rendered
+     * via `renderRow` never gets an expanded-content row appended, even when
+     * `getRowCanExpand` returns true for it. Read `row.getIsExpanded()` and
+     * render the expanded content yourself if you need both.
+     */
+    renderRow?: (row: Row<TData>, rowIndex: number) => ReactNode;
+    /**
+     * Renders a custom empty state instead of the default "No results." row.
+     * Receives `hasFilters` (whether any column filter is currently applied) so
+     * the caller can distinguish "no data at all" from "no matches" — the
+     * actual copy/wording/localization stays the caller's job.
+     */
+    renderEmptyState?: (context: {
+        hasFilters: boolean;
+    }) => ReactNode;
+    /**
+     * `'page'` (default) keeps today's client-paginated behavior. `'infinite'`
+     * omits the paginated row model — `data` is assumed to be the full
+     * accumulated array the caller appends to on each `onLoadMore` — and
+     * renders a sentinel row that calls `onLoadMore` once it scrolls into view.
+     * Does not compose with virtualization; for a large accumulated list, use
+     * the `VirtualScrolling` recipe over the raw `Table` primitives instead.
+     */
+    paginationMode?: 'page' | 'infinite';
+    /**
+     * Called when the infinite-scroll sentinel intersects the viewport.
+     * `paginationMode="infinite"` only. The fetch-more call, cursor/offset
+     * tracking, dedup, and accumulating `data` stay the caller's job. Requires
+     * at least one row already rendered — an empty table with `data={[]}`
+     * cannot use the sentinel to drive its very first fetch; seed the first
+     * page yourself (e.g. on mount) and use `onLoadMore` for subsequent pages.
+     */
+    onLoadMore?: () => void;
+    /**
+     * Expands the sentinel's `IntersectionObserver` root margin (native CSS
+     * margin syntax, e.g. `'400px'`) so `onLoadMore` fires before the sentinel
+     * is literally visible — the closer the caller's fetch is to finishing by
+     * the time the user actually scrolls there, the less often the trailing
+     * loading row is seen. `paginationMode="infinite"` only; no-op when `table`
+     * is passed. How far this actually prefetches also depends on page size —
+     * a large margin with small pages can trigger several `onLoadMore` calls
+     * back-to-back as the user scrolls normally, which is expected.
+     */
+    loadMoreRootMargin?: string;
+    /** Whether more rows are available to load. `paginationMode="infinite"` only. */
+    hasNextPage?: boolean;
+    /**
+     * Whether a load is in flight — suppresses further `onLoadMore` calls and
+     * renders a trailing loading row. `paginationMode="infinite"` only.
+     */
+    isLoadingMore?: boolean;
+}
+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 {};

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

@@ -0,0 +1,106 @@
+import { ReactNode } from 'react';
+/** Props for `DataTable`. */
+export interface DataTableProps {
+    /**
+     * TanStack column definitions — header/cell renderers and accessors. Required
+     * unless `table` (an externally-built instance) is passed.
+     */
+    columns?: unknown[];
+    /** The row data. Required unless `table` is passed. */
+    data?: unknown[];
+    /**
+     * Render from an externally-built TanStack `table` instance instead of
+     * DataTable's own — DataTable then owns no state and renders the caller's
+     * 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`,
+     * `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()`.
+     */
+    table?: 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;
+    /**
+     * Opt in to interactive column resizing — renders a drag handle at the
+     * trailing edge of each resizable header (TanStack's native `columnResizing`).
+     */
+    enableColumnResizing?: boolean;
+    /** Passthrough for the `columnSizing` state so a consumer can persist widths. */
+    onColumnSizingChange?: (updater: unknown) => void;
+    /**
+     * Controlled column-visibility state — pass this (with
+     * `onColumnVisibilityChange`) to share one visibility state with an external
+     * `useReactTable` instance. Uncontrolled (internal state) when omitted.
+     */
+    columnVisibility?: unknown;
+    /** Passthrough for the `columnVisibility` state; pairs with `columnVisibility`. */
+    onColumnVisibilityChange?: (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
+     * the caller).
+     */
+    manualSorting?: boolean;
+    /**
+     * Controlled sorting state — pass this (with `onSortingChange`) to drive
+     * sorting externally. Uncontrolled (internal state) when omitted.
+     */
+    sorting?: unknown;
+    /** Passthrough for the `sorting` state; pairs with `sorting`. */
+    onSortingChange?: (updater: unknown) => void;
+    /**
+     * Renders a full row, bypassing DataTable's default per-cell `flexRender`
+     * path entirely. Use to swap in a custom, independently memoizable row
+     * component — the caller owns the row's markup and equality semantics. Reuse
+     * the exported `getCellStyle`/`getPinnedStyle`/`getColumnWidth` helpers to
+     * match DataTable's default cell styling if desired. Also bypasses
+     * `renderExpandedRow` — a row rendered via `renderRow` never gets an
+     * expanded-content row appended.
+     */
+    renderRow?: (row: unknown, rowIndex: number) => ReactNode;
+    /**
+     * Renders a custom empty state instead of the default "No results." row.
+     * Receives `hasFilters` (whether any column filter is currently applied).
+     */
+    renderEmptyState?: (context: {
+        hasFilters: boolean;
+    }) => ReactNode;
+    /**
+     * `'page'` (default) keeps today's client-paginated behavior. `'infinite'`
+     * omits the paginated row model — `data` is the full accumulated array the
+     * caller appends to on each `onLoadMore` — and renders a sentinel row that
+     * calls `onLoadMore` once it scrolls into view.
+     */
+    paginationMode?: 'page' | 'infinite';
+    /**
+     * Called when the infinite-scroll sentinel intersects the viewport.
+     * `paginationMode="infinite"` only.
+     */
+    onLoadMore?: () => void;
+    /**
+     * Expands the sentinel's `IntersectionObserver` root margin (native CSS
+     * margin syntax, e.g. `'400px'`). `paginationMode="infinite"` only.
+     */
+    loadMoreRootMargin?: string;
+    /** Whether more rows are available to load. `paginationMode="infinite"` only. */
+    hasNextPage?: boolean;
+    /**
+     * Whether a load is in flight — suppresses further `onLoadMore` calls and
+     * renders a trailing loading row. `paginationMode="infinite"` only.
+     */
+    isLoadingMore?: boolean;
+}

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

@@ -0,0 +1,6 @@
+export { DataTable, type DataTableProps, getCellStyle, getPinnedStyle, getColumnWidth, } 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';