@acronis-platform/ui-react 0.57.1 → 0.58.0

package/dist/react.js.map

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

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

@@ -0,0 +1,49 @@
+import { VariantProps } from 'class-variance-authority';
+import { ChartTooltip, ChartConfig } from '../chart';
+import * as React from 'react';
+declare const areaChartVariants: (props?: ({
+    layout?: "single" | "stacked" | null | undefined;
+    fill?: "solid" | "gradient" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface AreaChartProps extends Omit<React.ComponentProps<'div'>, 'children'>, VariantProps<typeof areaChartVariants> {
+    /** Row-per-point data. Each object holds the category key + one numeric field per series (`null` breaks the area unless `connectNulls`). */
+    data: ReadonlyArray<Record<string, string | number | null>>;
+    /**
+     * Per-series map of `label` / `color` (imported from the shared `Chart`
+     * primitives). Series colors are caller-supplied — reference an existing
+     * semantic `--ui-*` token; there is no chart palette tier yet.
+     */
+    config: ChartConfig;
+    /** Series to plot — one `<Area>` per key. Each must exist in `config` and in every data row. */
+    dataKeys: string[];
+    /** Category axis key (the shared dimension across rows, e.g. `"month"`). */
+    xKey: 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;
+    /** Interpolation between points. */
+    curve?: 'linear' | 'monotone' | 'step';
+    /** Stroke width of each area's top border. */
+    strokeWidth?: number;
+    /** Flat-fill opacity — used only when `fill="solid"` (gradient controls its own stops). */
+    fillOpacity?: number;
+    /** Render a dot at each data point. */
+    showDots?: boolean;
+    /** Bridge `null` gaps in the data instead of breaking the area. */
+    connectNulls?: 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` /
+     * `indicator` — to customize formatting, per-series rows, or extra fields
+     * without composing recharts yourself. Ignored when `showTooltip` is false.
+     */
+    tooltipContent?: React.ComponentProps<typeof ChartTooltip>['content'];
+}
+declare const AreaChart: React.ForwardRefExoticComponent<Omit<AreaChartProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { AreaChart, areaChartVariants };

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

@@ -0,0 +1 @@
+export { AreaChart, areaChartVariants, type AreaChartProps } from './area-chart';

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

@@ -2,7 +2,7 @@ import { Avatar as AvatarPrimitive } from '@base-ui/react/avatar';
 import { VariantProps } from 'class-variance-authority';
 import * as React from 'react';
 declare const avatarVariants: (props?: ({
-    color?: "teal" | "violet" | "red" | "yellow" | "orange" | null | undefined;
+    color?: "orange" | "red" | "teal" | "violet" | "yellow" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 export interface AvatarProps extends React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Root>, VariantProps<typeof avatarVariants> {
 }

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

@@ -1,10 +1,29 @@
 import { VariantProps } from 'class-variance-authority';
-import { ChartConfig } from '../chart';
+import { ChartTooltip, ChartConfig } from '../chart';
 import * as React from 'react';
 declare const barChartVariants: (props?: ({
     orientation?: "horizontal" | "vertical" | null | undefined;
-    layout?: "grouped" | "stacked" | null | undefined;
+    layout?: "stacked" | "grouped" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface BarChartReferenceLine {
+    /** Fixed position on the value axis. Takes precedence over `average`. */
+    value?: number;
+    /**
+     * Draw the line at the mean of one series (a `dataKeys` entry) or, when
+     * `true`, of every plotted series' values.
+     */
+    average?: boolean | string;
+    /** Optional caption rendered alongside the line. */
+    label?: string;
+}
+/**
+ * Resolve a `referenceLine` config to a position on the value axis: a fixed
+ * `value` wins; otherwise the mean of the requested series (a single `dataKeys`
+ * entry, or all of them when `average` is `true`). Returns `undefined` when
+ * there is nothing to draw (no config, or no numeric values to average).
+ * Exported for unit tests; not part of the package's public API.
+ */
+export declare function barChartReferenceValue(referenceLine: BarChartReferenceLine | undefined, data: ReadonlyArray<Record<string, string | number>>, dataKeys: string[]): number | undefined;
 export interface BarChartProps extends Omit<React.ComponentProps<'div'>, 'children'>, VariantProps<typeof barChartVariants> {
     /** Row-per-category data. Each object holds the category key + one numeric field per series. */
     data: ReadonlyArray<Record<string, string | number>>;
@@ -18,11 +37,32 @@ export interface BarChartProps extends Omit<React.ComponentProps<'div'>, 'childr
     dataKeys: string[];
     /** Category axis key (the shared dimension across rows, e.g. `"month"`). */
     xKey: string;
+    /**
+     * One or more dashed reference/average lines on the value axis (Y for vertical
+     * bars, X for horizontal). Each is driven by a fixed `value` or a computed
+     * series `average`. Pass a single object or an array to draw several at once.
+     */
+    referenceLine?: BarChartReferenceLine | BarChartReferenceLine[];
+    /** Title rendered beneath the horizontal (X) axis. */
+    xAxisLabel?: string;
+    /** Title rendered beside the vertical (Y) axis (rotated). */
+    yAxisLabel?: string;
+    /** Unit suffix on X-axis tick values (recharts `unit`) — applies when the X axis is numeric (`orientation="horizontal"`). */
+    xUnit?: string;
+    /** Unit suffix on Y-axis tick values (recharts `unit`) — applies when the Y axis is numeric (`orientation="vertical"`). */
+    yUnit?: string;
     /** Corner radius applied to the growing end of each bar. */
     barRadius?: number;
     showGrid?: boolean;
     showTooltip?: boolean;
     showLegend?: boolean;
+    /**
+     * Replace the default tooltip. Pass a configured `ChartTooltipContent`
+     * (imported from this library) — e.g. with a `formatter` / `labelFormatter` /
+     * `indicator` — to customize formatting, per-series rows, or extra fields
+     * without composing recharts yourself. Ignored when `showTooltip` is false.
+     */
+    tooltipContent?: React.ComponentProps<typeof ChartTooltip>['content'];
 }
 declare const BarChart: React.ForwardRefExoticComponent<Omit<BarChartProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
 export { BarChart, barChartVariants };

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

@@ -1 +1 @@
-export { BarChart, barChartVariants, type BarChartProps } from './bar-chart';
+export { BarChart, barChartVariants, type BarChartProps, type BarChartReferenceLine, } from './bar-chart';

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

@@ -0,0 +1,21 @@
+import { useRender } from '@base-ui/react/use-render';
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const buttonIconInputVariants: (props?: ({
+    variant?: "error" | "normal" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface ButtonIconInputProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonIconInputVariants> {
+    /**
+     * 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;
+}
+/**
+ * Small icon-only button meant to sit inside an input's box. The icon is
+ * passed as `children`; provide an `aria-label` (or `aria-labelledby`) so the
+ * control has an accessible name.
+ */
+declare const ButtonIconInput: React.ForwardRefExoticComponent<ButtonIconInputProps & React.RefAttributes<HTMLButtonElement>>;
+export { ButtonIconInput, buttonIconInputVariants };

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

@@ -0,0 +1 @@
+export { ButtonIconInput, buttonIconInputVariants, type ButtonIconInputProps, } from './button-icon-input';

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

@@ -11,6 +11,11 @@ export interface CardFilterProps extends Omit<React.HTMLAttributes<HTMLElement>,
     value?: React.ReactNode;
     /** Optional leading icon (16px) rendered before the value. Hidden for `static-empty`. */
     icon?: React.ReactNode;
+    /**
+     * `clickable` only — applies the selected (active) styling and exposes the
+     * card as a pressed toggle (`aria-pressed`). Controlled only.
+     */
+    selected?: boolean;
     /**
      * Replace the rendered element (`<button>` for `clickable`, otherwise `<div>`)
      * with another element or component (Base UI composition) — e.g. a router link

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

@@ -0,0 +1,11 @@
+import * as React from 'react';
+export interface ChartStateProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'children'> {
+    /** Which placeholder to show. Drives the leading glyph and default label. */
+    state: 'loading' | 'empty' | 'error';
+    /** Overrides the default label for the current `state`. */
+    message?: string;
+    /** Trailing action (e.g. a "Try again" button) — shown for `error` only. */
+    action?: React.ReactNode;
+}
+declare const ChartState: React.ForwardRefExoticComponent<ChartStateProps & React.RefAttributes<HTMLDivElement>>;
+export { ChartState };

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

@@ -0,0 +1 @@
+export { ChartState, type ChartStateProps } from './chart-state';

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

@@ -0,0 +1,48 @@
+import { ChartTooltip, ChartConfig } from '../chart';
+import * as React from 'react';
+export type ComposedSeriesType = 'bar' | 'line' | 'area';
+export interface ComposedSeries {
+    /** Column key to plot — must match a `config` entry; drives its `--color-<key>` paint. */
+    key: string;
+    /** How this series renders. */
+    type: ComposedSeriesType;
+}
+export interface ComposedChartProps extends Omit<React.ComponentProps<'div'>, 'children'> {
+    /** Row-per-category data. Each object holds `xKey` + one numeric field per series. */
+    data: ReadonlyArray<Record<string, string | number>>;
+    /**
+     * Per-series map of `label` / `color`, keyed by `series[].key` (imported from
+     * the shared `Chart` primitives). Turned into `--color-<key>` custom
+     * properties. Colors are caller-supplied — reference an existing semantic
+     * `--ui-*` token; there is no chart palette tier yet.
+     */
+    config: ChartConfig;
+    /** Series to plot, each `{ key, type }` — one bar/line/area per entry. Each key must exist in `config` and every data row. */
+    series: ComposedSeries[];
+    /** Category axis key (the shared dimension across rows, e.g. `"month"`). */
+    xKey: 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;
+    /** Interpolation for the line and area series. */
+    curve?: 'linear' | 'monotone' | 'step';
+    /** Corner radius on the growing end of bar series. */
+    barRadius?: number;
+    /** Flat-fill opacity for area series. */
+    fillOpacity?: number;
+    showGrid?: boolean;
+    showTooltip?: boolean;
+    showLegend?: boolean;
+    /**
+     * Replace the default tooltip. Pass a configured `ChartTooltipContent`
+     * (imported from this library) — e.g. with a `formatter` / `labelFormatter` /
+     * `indicator` — to customize formatting, per-series rows, or extra fields
+     * without composing recharts yourself. Ignored when `showTooltip` is false.
+     */
+    tooltipContent?: React.ComponentProps<typeof ChartTooltip>['content'];
+}
+declare const ComposedChart: React.ForwardRefExoticComponent<Omit<ComposedChartProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { ComposedChart };

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

@@ -0,0 +1 @@
+export { ComposedChart, type ComposedChartProps, type ComposedSeries, type ComposedSeriesType, } from './composed-chart';

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/dialog/dialog.d.ts

@@ -2,17 +2,18 @@ import { Dialog as DialogPrimitive } from '@base-ui/react/dialog';
 import { VariantProps } from 'class-variance-authority';
 import * as React from 'react';
 declare const dialogContentVariants: (props?: ({
-    size?: "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | null | undefined;
+    size?: "sm" | "large" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
-declare const Dialog: typeof DialogPrimitive.Root;
+declare const DialogRoot: typeof DialogPrimitive.Root;
 declare const DialogTrigger: DialogPrimitive.Trigger;
 declare const DialogPortal: React.ForwardRefExoticComponent<Omit<import('@base-ui/react').AlertDialogPortalProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
 declare const DialogClose: React.ForwardRefExoticComponent<Omit<import('@base-ui/react').AlertDialogCloseProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
 declare const DialogOverlay: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').AlertDialogBackdropProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
 export interface DialogContentProps extends React.ComponentPropsWithoutRef<typeof DialogPrimitive.Popup>, VariantProps<typeof dialogContentVariants> {
     /**
-     * Popup max-width. `sm` 512 · `xs` 464 · `md` 672 · `lg` 832 · `xl` 992 ·
-     * `2xl` 1136 (px). Defaults to `sm`.
+     * Popup max-width. `sm` (512px, default) is the Figma-defined size; `large`
+     * (832px) is a backward-compatibility size with no design token (see the
+     * `Large` story).
      */
     size?: VariantProps<typeof dialogContentVariants>['size'];
     /**
@@ -30,10 +31,105 @@ export interface DialogContentProps extends React.ComponentPropsWithoutRef<typeo
     keepMounted?: DialogPrimitive.Portal.Props['keepMounted'];
 }
 declare const DialogContent: React.ForwardRefExoticComponent<DialogContentProps & React.RefAttributes<HTMLDivElement>>;
-declare const DialogHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
-declare const DialogFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
-declare const DialogBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogHeaderRoot: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogFooterRoot: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogBodyRoot: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
 declare const DialogTitle: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').AlertDialogTitleProps, "ref"> & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
 declare const DialogDescription: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').AlertDialogDescriptionProps, "ref"> & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
-declare const DialogCloseButton: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').AlertDialogCloseProps, "ref"> & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
-export { Dialog, DialogPortal, DialogOverlay, DialogClose, DialogCloseButton, DialogTrigger, DialogContent, DialogHeader, DialogFooter, DialogTitle, DialogBody, DialogDescription, dialogContentVariants, };
+export interface DialogCloseButtonProps extends React.ComponentPropsWithoutRef<typeof DialogPrimitive.Close> {
+    /** Accessible name for screen readers. Defaults to `'Close'`. */
+    closeLabel?: string;
+}
+declare const DialogCloseButton: React.ForwardRefExoticComponent<DialogCloseButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export type DialogVariant = 'default' | 'rename' | 'save changes' | 'reset password' | 'discard changes' | 'accept' | 'read-only' | 'wide';
+type DialogRootProps = React.ComponentPropsWithoutRef<typeof DialogRoot>;
+export interface DialogProps extends Omit<DialogRootProps, 'children'> {
+    /**
+     * Selects the canned title / body / footer preset. Defaults to `'default'`.
+     * `'wide'` is a legacy escape hatch (no canned preset) kept for backward
+     * compatibility — pair it with `size="large"` and the `footer` prop.
+     */
+    variant?: DialogVariant;
+    /**
+     * Show a spinner overlay across the body + footer, and make both `inert`
+     * (unfocusable, unclickable, hidden from assistive tech) so a keyboard user
+     * can't activate the visually obscured footer buttons while busy.
+     */
+    hasLoading?: boolean;
+    /**
+     * Overrides the loading overlay's accessible label. Defaults to `Loading`'s
+     * own default (`'Data is loading…'`). Ignored when `hasLoading` is `false`.
+     */
+    loadingLabel?: string;
+    /**
+     * Show the header (title + close button). Defaults to `true`. When `false`,
+     * the title is still rendered off-screen so the dialog keeps an accessible
+     * name — only the visible bar and close button are omitted. Beyond the
+     * strict Figma contract (all seven `DialogDefault` variants always show the
+     * header); a ui-react-only extension, like `wide`/`size="large"`.
+     */
+    hasHeader?: boolean;
+    /**
+     * Show the footer (action buttons). Defaults to `true`. Beyond the strict
+     * Figma contract (all seven `DialogDefault` variants always show the
+     * footer); a ui-react-only extension, like `wide`/`size="large"`. When
+     * `false`, `footer` (and the canned footer it would otherwise replace) is
+     * not rendered either.
+     */
+    hasFooter?: boolean;
+    /** Overrides the variant's default body content. */
+    children?: React.ReactNode;
+    /** Overrides the variant's default title. */
+    title?: string;
+    /**
+     * The real name of the object being acted on (e.g. a file or resource
+     * name). Interpolated into the `rename`/`discard changes`/`accept`
+     * variants' canned title/body in place of the generic placeholder text;
+     * ignored by variants that don't reference an object name.
+     */
+    objectName?: string;
+    /**
+     * Overrides the accessible name of the `rename` variant's text field
+     * (default `'Object name'`). Ignored by every other variant.
+     */
+    objectNameLabel?: string;
+    /**
+     * Overrides the variant's default secondary (dismiss) button label. Passing
+     * this for a variant with no secondary button by default (e.g. `read-only`)
+     * also makes the button appear. Ignored when `footer` is provided.
+     */
+    secondaryLabel?: string;
+    /** Overrides the variant's default primary button label. Ignored when `footer` is provided. */
+    primaryLabel?: string;
+    /**
+     * Fires when the primary footer button is clicked. The dialog does not
+     * close automatically afterwards — pair this with `open`/`onOpenChange` to
+     * close it once the action completes. Ignored when `footer` is provided
+     * (wire behavior onto your own buttons there instead).
+     */
+    onPrimaryAction?: () => void;
+    /**
+     * Replaces the footer's action content entirely with free-form buttons —
+     * the escape hatch the `wide` variant is meant to be paired with, for
+     * legacy call sites that don't fit one of the seven canned presets. Ignored
+     * (along with the canned footer) when `hasFooter` is `false`.
+     */
+    footer?: React.ReactNode;
+    /** Overrides the close button's accessible name. Defaults to `'Close'`. */
+    closeLabel?: string;
+    /**
+     * Popup max-width (forwarded to `DialogContent`). Defaults to `'sm'`, or to
+     * `'large'` when `variant` is `'wide'`.
+     */
+    size?: DialogContentProps['size'];
+    /** Render inside a portal (forwarded to `DialogContent`). Defaults to `true`. */
+    portal?: boolean;
+    /** Portal container (forwarded to `DialogContent`). */
+    portalContainer?: DialogContentProps['portalContainer'];
+    /** Keep the content mounted while closed (forwarded to `DialogContent`). */
+    keepMounted?: DialogContentProps['keepMounted'];
+    /** Extra classes merged onto the popup container. */
+    className?: string;
+}
+declare const Dialog: React.ForwardRefExoticComponent<DialogProps & React.RefAttributes<HTMLDivElement>>;
+export { DialogRoot, DialogPortal, DialogOverlay, DialogClose, DialogCloseButton, DialogTrigger, DialogContent, DialogHeaderRoot, DialogFooterRoot, DialogTitle, DialogBodyRoot, DialogDescription, dialogContentVariants, Dialog, };

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

@@ -1,11 +1,8 @@
 import type * as React from 'react';
 /** Props for `DialogContent` — the portaled, centered dialog popup. */
 export interface DialogContentProps {
-    /**
-     * Popup max-width. One of `xs` (464px) · `sm` (512px, default) · `md` (672px)
-     * · `lg` (832px) · `xl` (992px) · `2xl` (1136px).
-     */
-    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+    /** Popup max-width. `sm` (512px, default) is the Figma-defined size; `large` (832px) is a legacy backward-compatibility size. */
+    size?: 'sm' | 'large';
     /**
      * Render the content inside a portal (default `true`). Disable only when you
      * supply your own `DialogPortal` ancestor (e.g. inline usage).
@@ -22,3 +19,83 @@ export interface DialogContentProps {
     className?: string;
     children?: React.ReactNode;
 }
+/** Props for `Dialog` — the public, variant-driven dialog recipe. */
+export interface DialogProps {
+    /**
+     * Selects the canned title / body / footer preset. Defaults to `'default'`.
+     * `'wide'` is a legacy escape hatch (no Figma preset) kept for backward
+     * compatibility — pair it with `size="large"` and the `footer` prop.
+     */
+    variant?: 'default' | 'rename' | 'save changes' | 'reset password' | 'discard changes' | 'accept' | 'read-only' | 'wide';
+    /**
+     * Show a spinner overlay across the body + footer, and make both `inert`
+     * so a keyboard user can't activate the obscured footer buttons.
+     */
+    hasLoading?: boolean;
+    /** Overrides the loading overlay's accessible label. Ignored when `hasLoading` is `false`. */
+    loadingLabel?: string;
+    /**
+     * Show the header (title + close button). Defaults to `true`. When `false`,
+     * the title is still rendered off-screen so the dialog keeps an accessible
+     * name — only the visible bar and close button are omitted.
+     */
+    hasHeader?: boolean;
+    /** Show the footer (action buttons). Defaults to `true`. When `false`, `footer` is not rendered either. */
+    hasFooter?: boolean;
+    /** Overrides the variant's default body content. */
+    children?: React.ReactNode;
+    /** Overrides the variant's default title. */
+    title?: string;
+    /**
+     * The real name of the object being acted on (e.g. a file or resource
+     * name). Interpolated into the `rename`/`discard changes`/`accept`
+     * variants' canned title/body in place of the generic placeholder text;
+     * ignored by variants that don't reference an object name.
+     */
+    objectName?: string;
+    /**
+     * Overrides the accessible name of the `rename` variant's text field
+     * (default `'Object name'`). Ignored by every other variant.
+     */
+    objectNameLabel?: string;
+    /**
+     * Overrides the variant's default secondary (dismiss) button label. Passing
+     * this on a variant with no secondary button by default (e.g. `read-only`)
+     * also makes the button appear. Ignored when `footer` is provided.
+     */
+    secondaryLabel?: string;
+    /** Overrides the variant's default primary button label. Ignored when `footer` is provided. */
+    primaryLabel?: string;
+    /**
+     * Fires when the primary footer button is clicked. The dialog does not
+     * close automatically afterwards — pair this with `open`/`onOpenChange` to
+     * close it once the action completes. Ignored when `footer` is provided.
+     */
+    onPrimaryAction?: () => void;
+    /**
+     * Replaces the footer's action content entirely with free-form buttons —
+     * the escape hatch the `wide` variant is meant to be paired with, for
+     * legacy call sites that don't fit one of the seven canned presets.
+     */
+    footer?: React.ReactNode;
+    /** Overrides the close button's accessible name. Defaults to `'Close'`. */
+    closeLabel?: string;
+    /** Popup max-width. Defaults to `'sm'`, or to `'large'` when `variant` is `'wide'`. */
+    size?: 'sm' | 'large';
+    /** Render inside a portal (default `true`). */
+    portal?: boolean;
+    /** Portal container. Pass a shadow-root mount for isolated-style previews. */
+    portalContainer?: HTMLElement | null;
+    /** Keep the content mounted while closed. */
+    keepMounted?: boolean;
+    /** Extra classes merged onto the popup container. */
+    className?: string;
+    /** Controlled open state. Pair with `onOpenChange`. */
+    open?: boolean;
+    /** Open on mount, uncontrolled. */
+    defaultOpen?: boolean;
+    /** Modal behavior — focus trap and scroll lock while open. Defaults to `true`. */
+    modal?: boolean | 'trap-focus';
+    /** Fires when the dialog opens or closes. */
+    onOpenChange?: (open: boolean, eventDetails: unknown) => void;
+}

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

@@ -1 +1 @@
-export { Dialog, DialogPortal, DialogOverlay, DialogClose, DialogCloseButton, DialogTrigger, DialogContent, DialogHeader, DialogFooter, DialogTitle, DialogBody, DialogDescription, dialogContentVariants, type DialogContentProps, } from './dialog';
+export { DialogRoot, DialogPortal, DialogOverlay, DialogClose, DialogCloseButton, DialogTrigger, DialogContent, DialogHeaderRoot, DialogFooterRoot, DialogTitle, DialogBodyRoot, DialogDescription, dialogContentVariants, Dialog, type DialogContentProps, type DialogCloseButtonProps, type DialogProps, type DialogVariant, } from './dialog';

package/dist/src/components/ui/dialog-footer-default/dialog-footer-default.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+export interface DialogFooterDefaultProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    /** Truncated description text next to the actions. Mutually exclusive with `link`. */
+    description?: string;
+    /** A `Link` (or similar) element next to the actions. Mutually exclusive with `description`. */
+    link?: React.ReactNode;
+    /** End-aligned actions — typically a secondary and a primary `Button`. */
+    children?: React.ReactNode;
+}
+declare const DialogFooterDefault: React.ForwardRefExoticComponent<DialogFooterDefaultProps & React.RefAttributes<HTMLDivElement>>;
+export { DialogFooterDefault };

package/dist/src/components/ui/dialog-footer-default/index.d.ts

@@ -0,0 +1 @@
+export { DialogFooterDefault, type DialogFooterDefaultProps } from './dialog-footer-default';

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

@@ -16,7 +16,7 @@ interface FilterSearchFiltersContextValue {
  * `onChange` to `setFilter`; Apply commits the draft, Cancel/dismiss reverts it.
  */
 export declare function useFilterSearchFilters(): FilterSearchFiltersContextValue;
-export interface FilterSearchFiltersProps {
+export interface FilterSearchFiltersProps extends Omit<React.ComponentPropsWithoutRef<'button'>, 'value' | 'onValueChange'> {
     /** The applied filter values, keyed by an arbitrary consumer-chosen id. */
     value: Record<string, unknown>;
     /** Called with the committed filters when Apply is pressed. */

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

@@ -0,0 +1,39 @@
+import { VariantProps } from 'class-variance-authority';
+import { ChartTooltip, ChartConfig } from '../chart';
+import * as React from 'react';
+declare const funnelChartVariants: (props?: ({
+    lastShape?: "triangle" | "rectangle" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface FunnelChartProps extends Omit<React.ComponentProps<'div'>, 'children'>, VariantProps<typeof funnelChartVariants> {
+    /** Row-per-stage data. Each object holds the stage's `nameKey` label + its `dataKey` numeric value. */
+    data: ReadonlyArray<Record<string, string | number>>;
+    /**
+     * Per-stage map of `label` / `color`, keyed by the stage's `nameKey` value
+     * (imported from the shared `Chart` primitives). Turned into `--color-<name>`
+     * custom properties. Colors are caller-supplied — reference an existing
+     * semantic `--ui-*` token; there is no chart palette tier yet.
+     */
+    config: ChartConfig;
+    /** Numeric field that sizes each stage (the funnel narrows as it drops). */
+    dataKey: string;
+    /**
+     * Label field that names each stage (drives the legend, tooltip, on-chart
+     * labels, and the `--color-<name>` lookup). Values should be unique per chart —
+     * stages sharing a name share one `config`/color entry.
+     */
+    nameKey: string;
+    /** Flip the funnel so it widens toward the bottom instead of narrowing. */
+    reversed?: boolean;
+    /** Render each stage's name beside its segment. */
+    showLabels?: boolean;
+    showTooltip?: boolean;
+    /**
+     * Replace the default tooltip. Pass a configured `ChartTooltipContent`
+     * (imported from this library) — e.g. with a `formatter` / `labelFormatter` —
+     * to customize formatting, per-series rows, or extra fields without composing
+     * recharts yourself. Ignored when `showTooltip` is false.
+     */
+    tooltipContent?: React.ComponentProps<typeof ChartTooltip>['content'];
+}
+declare const FunnelChart: React.ForwardRefExoticComponent<Omit<FunnelChartProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { FunnelChart, funnelChartVariants };

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

@@ -0,0 +1 @@
+export { FunnelChart, funnelChartVariants, type FunnelChartProps, } from './funnel-chart';