@acronis-platform/ui-react 0.57.0 → 0.57.1

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';

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

@@ -0,0 +1,39 @@
+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;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare const Dialog: 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`.
+     */
+    size?: VariantProps<typeof dialogContentVariants>['size'];
+    /**
+     * Render the content inside a portal (default `true`). Base UI requires the
+     * Popup to sit in a Portal for correct stacking; set `false` for inline usage
+     * (e.g. when the caller supplies its own `DialogPortal`, or in tests).
+     */
+    portal?: boolean;
+    /**
+     * Portal container. Pass a shadow-root mount for isolated-style previews
+     * (the docs demos do this via `useShadowMount`).
+     */
+    portalContainer?: DialogPrimitive.Portal.Props['container'];
+    /** Keep the content mounted while closed (Base UI `Portal` prop). */
+    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 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, };

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

@@ -0,0 +1,24 @@
+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';
+    /**
+     * Render the content inside a portal (default `true`). Disable only when you
+     * supply your own `DialogPortal` ancestor (e.g. inline usage).
+     */
+    portal?: boolean;
+    /**
+     * Portal container. Pass a shadow-root mount for isolated-style previews
+     * (the docs demos do this via `useShadowMount`).
+     */
+    portalContainer?: HTMLElement | null;
+    /** Keep the content mounted while closed. */
+    keepMounted?: boolean;
+    /** Extra classes merged onto the popup. */
+    className?: string;
+    children?: React.ReactNode;
+}

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

@@ -0,0 +1 @@
+export { Dialog, DialogPortal, DialogOverlay, DialogClose, DialogCloseButton, DialogTrigger, DialogContent, DialogHeader, DialogFooter, DialogTitle, DialogBody, DialogDescription, dialogContentVariants, type DialogContentProps, } from './dialog';

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

@@ -0,0 +1,32 @@
+import { Menu as MenuPrimitive } from '@base-ui/react/menu';
+import * as React from 'react';
+declare const DropdownMenu: <Payload>(props: MenuPrimitive.Root.Props<Payload>) => import("react/jsx-runtime").JSX.Element;
+declare const DropdownMenuTrigger: MenuPrimitive.Trigger;
+declare const DropdownMenuGroup: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').ContextMenuGroupProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React.ForwardRefExoticComponent<Omit<import('@base-ui/react').ContextMenuPortalProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSub: typeof MenuPrimitive.SubmenuRoot;
+export interface DropdownMenuContentProps extends React.ComponentPropsWithoutRef<typeof MenuPrimitive.Popup> {
+    side?: MenuPrimitive.Positioner.Props['side'];
+    align?: MenuPrimitive.Positioner.Props['align'];
+    sideOffset?: number;
+    /** Render inside a portal (default `true`). */
+    portal?: boolean;
+    /** Portal container — pass a shadow-root mount for isolated-style previews. */
+    portalContainer?: MenuPrimitive.Portal.Props['container'];
+    keepMounted?: MenuPrimitive.Portal.Props['keepMounted'];
+}
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').ContextMenuPopupProps, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    sideOffset?: number;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').ContextMenuItemProps, "ref"> & React.RefAttributes<HTMLElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLElement>>;
+declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<Omit<import('@base-ui/react').ContextMenuSubmenuTriggerProps, "ref"> & React.RefAttributes<HTMLElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLElement>>;
+declare function DropdownMenuShortcut({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+declare namespace DropdownMenuShortcut {
+    var displayName: string;
+}
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuPortal, };

package/dist/src/components/ui/dropdown-menu/dropdown-menu.docs.d.ts

@@ -0,0 +1,25 @@
+import type * as React from 'react';
+/** Props for `DropdownMenuContent` — the positioned, portaled menu popup. */
+export interface DropdownMenuContentProps {
+    /** Which side of the trigger to render on. Defaults to `bottom`. */
+    side?: 'top' | 'bottom' | 'left' | 'right' | 'inline-start' | 'inline-end';
+    /** Alignment along the chosen side. */
+    align?: 'start' | 'center' | 'end';
+    /** Distance in px from the trigger. Defaults to `4`. */
+    sideOffset?: number;
+    /**
+     * Render inside a portal (default `true`). Disable only when you supply your
+     * own `DropdownMenuPortal` ancestor.
+     */
+    portal?: boolean;
+    /**
+     * Portal container. Pass a shadow-root mount for isolated-style previews
+     * (the docs demos do this via `useShadowMount`).
+     */
+    portalContainer?: HTMLElement | null;
+    /** Keep the content mounted while closed. */
+    keepMounted?: boolean;
+    /** Extra classes merged onto the popup. */
+    className?: string;
+    children?: React.ReactNode;
+}

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

@@ -0,0 +1 @@
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuPortal, type DropdownMenuContentProps, } from './dropdown-menu';

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

@@ -0,0 +1,9 @@
+import * as React from 'react';
+declare const Empty: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const EmptyIcon: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const EmptyHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const EmptyTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLHeadingElement>>;
+declare const EmptyDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const EmptyActions: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const EmptyLinks: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export { Empty, EmptyIcon, EmptyHeader, EmptyTitle, EmptyDescription, EmptyActions, EmptyLinks, };

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

@@ -0,0 +1 @@
+export { Empty, EmptyIcon, EmptyHeader, EmptyTitle, EmptyDescription, EmptyActions, EmptyLinks, } from './empty';

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

@@ -0,0 +1,39 @@
+import { Field as FieldPrimitive } from '@base-ui/react/field';
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const fieldVariants: (props?: ({
+    orientation?: "horizontal" | "vertical" | "responsive" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface FieldProps extends Omit<React.ComponentProps<typeof FieldPrimitive.Root>, 'className'>, VariantProps<typeof fieldVariants> {
+    className?: string;
+}
+declare function Field({ className, orientation, ...props }: FieldProps): import("react/jsx-runtime").JSX.Element;
+export interface FieldLabelProps extends Omit<React.ComponentProps<typeof FieldPrimitive.Label>, 'className'> {
+    className?: string;
+}
+declare function FieldLabel({ className, ...props }: FieldLabelProps): import("react/jsx-runtime").JSX.Element;
+export interface FieldControlProps extends Omit<React.ComponentProps<typeof FieldPrimitive.Control>, 'className'> {
+    className?: string;
+}
+declare function FieldControl({ className, ...props }: FieldControlProps): import("react/jsx-runtime").JSX.Element;
+export interface FieldDescriptionProps extends Omit<React.ComponentProps<typeof FieldPrimitive.Description>, 'className'> {
+    className?: string;
+}
+declare function FieldDescription({ className, ...props }: FieldDescriptionProps): import("react/jsx-runtime").JSX.Element;
+export interface FieldErrorProps extends Omit<React.ComponentProps<typeof FieldPrimitive.Error>, 'className'> {
+    className?: string;
+}
+declare function FieldError({ className, ...props }: FieldErrorProps): import("react/jsx-runtime").JSX.Element;
+declare function FieldSet({ className, ...props }: React.ComponentProps<'fieldset'>): import("react/jsx-runtime").JSX.Element;
+export interface FieldLegendProps extends React.ComponentProps<'legend'> {
+    variant?: 'legend' | 'label';
+}
+declare function FieldLegend({ className, variant, ...props }: FieldLegendProps): import("react/jsx-runtime").JSX.Element;
+declare function FieldGroup({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function FieldContent({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function FieldTitle({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+export interface FieldSeparatorProps extends React.ComponentProps<'div'> {
+    children?: React.ReactNode;
+}
+declare function FieldSeparator({ children, className, ...props }: FieldSeparatorProps): import("react/jsx-runtime").JSX.Element;
+export { Field, FieldLabel, FieldControl, FieldDescription, FieldError, FieldSet, FieldLegend, FieldGroup, FieldContent, FieldTitle, FieldSeparator, };

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

@@ -0,0 +1,27 @@
+import type * as React from 'react';
+export interface FieldProps {
+    /** Label/control layout — stacked, inline, or stacked-then-inline at the @md container width. */
+    orientation?: 'vertical' | 'horizontal' | 'responsive';
+    /** Marks the field invalid (sets data-invalid + the control's aria-invalid). */
+    invalid?: boolean;
+    /** Disables the field and its control. */
+    disabled?: boolean;
+    /** Identifies the field when a form is submitted. */
+    name?: string;
+    /** When the field validates. */
+    validationMode?: 'onSubmit' | 'onBlur' | 'onChange';
+    children?: React.ReactNode;
+    className?: string;
+}
+export interface FieldErrorProps {
+    /** Which ValidityState shows the message; `true` always shows it. */
+    match?: boolean | keyof ValidityState;
+    children?: React.ReactNode;
+    className?: string;
+}
+export interface FieldLegendProps {
+    /** Large legend text or small label text. */
+    variant?: 'legend' | 'label';
+    children?: React.ReactNode;
+    className?: string;
+}

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

@@ -0,0 +1,2 @@
+export { Field, FieldLabel, FieldControl, FieldDescription, FieldError, FieldSet, FieldLegend, FieldGroup, FieldContent, FieldTitle, FieldSeparator, } from './field';
+export type { FieldProps, FieldLabelProps, FieldControlProps, FieldDescriptionProps, FieldErrorProps, FieldLegendProps, FieldSeparatorProps, } from './field';

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

@@ -0,0 +1,52 @@
+import * as React from 'react';
+export type FilterSearchProps = React.ComponentPropsWithoutRef<'div'>;
+declare const FilterSearch: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export type FilterSearchActionsProps = React.ComponentPropsWithoutRef<'div'>;
+declare const FilterSearchActions: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface FilterSearchFiltersContextValue {
+    /** The current draft filters being edited inside the popover. */
+    filters: Record<string, unknown>;
+    /** Set a single draft filter value by key. */
+    setFilter: (key: string, value: unknown) => void;
+}
+/**
+ * Bind a filter field child (rendered inside `FilterSearchFilters`'s popover) to
+ * the component's draft filters. Returns the current draft map and a per-key
+ * setter. Field children are plain JSX (no render prop) and wire their own
+ * `onChange` to `setFilter`; Apply commits the draft, Cancel/dismiss reverts it.
+ */
+export declare function useFilterSearchFilters(): FilterSearchFiltersContextValue;
+export interface FilterSearchFiltersProps {
+    /** The applied filter values, keyed by an arbitrary consumer-chosen id. */
+    value: Record<string, unknown>;
+    /** Called with the committed filters when Apply is pressed. */
+    onValueChange: (next: Record<string, unknown>) => void;
+    /** Called with the newly applied filters when Apply is pressed (fires alongside `onValueChange`). */
+    onApply?: (filters: Record<string, unknown>) => void;
+    /** Label for the filter trigger button. */
+    label?: React.ReactNode;
+    /**
+     * Filter field children rendered inside the popover form. Plain children —
+     * wire each field to the draft via `useFilterSearchFilters`. Group fields with
+     * a `Separator` as a layout convention if desired.
+     */
+    children?: React.ReactNode;
+    /** Additional classes merged onto the trigger button. */
+    className?: string;
+}
+declare const FilterSearchFilters: React.ForwardRefExoticComponent<FilterSearchFiltersProps & React.RefAttributes<HTMLButtonElement>>;
+export interface FilterSearchAppliedFiltersProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'children'> {
+    /** The currently applied filter values, keyed by an arbitrary consumer-chosen id. */
+    filters: Record<string, unknown>;
+    /** Called with the remaining filters when a chip is removed or "Reset filters" clears all. */
+    onValueChange: (next: Record<string, unknown>) => void;
+    /** Format an applied-filter chip's label. Defaults to `"<key>: <value>"`. */
+    getFilterChipLabel?: (key: string, value: unknown) => React.ReactNode;
+}
+/**
+ * Renders one removable chip per applied filter plus a "Reset filters" action
+ * that clears all filters immediately (no popover involved). Renders nothing
+ * when `filters` is empty.
+ */
+declare const FilterSearchAppliedFilters: React.ForwardRefExoticComponent<FilterSearchAppliedFiltersProps & React.RefAttributes<HTMLDivElement>>;
+export { FilterSearch, FilterSearchActions, FilterSearchFilters, FilterSearchAppliedFilters, };

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

@@ -0,0 +1,2 @@
+export { FilterSearch, FilterSearchActions, FilterSearchFilters, FilterSearchAppliedFilters, useFilterSearchFilters, } from './filter-search';
+export type { FilterSearchProps, FilterSearchActionsProps, FilterSearchFiltersProps, FilterSearchAppliedFiltersProps, } from './filter-search';

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

@@ -0,0 +1,6 @@
+import { FormProps as BaseFormProps } from '@base-ui/react/form';
+export interface FormProps<FormValues extends Record<string, unknown> = Record<string, unknown>> extends Omit<BaseFormProps<FormValues>, 'className'> {
+    className?: string;
+}
+declare function Form<FormValues extends Record<string, unknown> = Record<string, unknown>>({ className, ...props }: FormProps<FormValues>): import("react/jsx-runtime").JSX.Element;
+export { Form };

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

@@ -0,0 +1 @@
+export { Form, type FormProps } from './form';

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

@@ -0,0 +1,15 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const gridVariants: (props?: ({
+    cols?: 1 | 2 | 6 | 3 | 4 | 12 | null | undefined;
+    gap?: "none" | "sm" | "md" | "lg" | "xl" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface GridProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof gridVariants> {
+    /**
+     * Size columns by the grid's own width (container queries) instead of the
+     * viewport. Wraps the grid in a `@container/grid`.
+     */
+    container?: boolean;
+}
+declare const Grid: React.ForwardRefExoticComponent<GridProps & React.RefAttributes<HTMLDivElement>>;
+export { Grid, gridVariants };

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

@@ -0,0 +1 @@
+export { Grid, gridVariants, type GridProps } from './grid';

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

@@ -0,0 +1 @@
+export { InputBox, type InputBoxProps } from './input';

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

@@ -0,0 +1,4 @@
+import * as React from 'react';
+export type InputBoxProps = React.ComponentPropsWithoutRef<'input'>;
+declare const InputBox: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+export { InputBox };

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

@@ -0,0 +1 @@
+export { InputDatePicker, type InputDatePickerProps, } from './input-date-picker';

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

@@ -0,0 +1,27 @@
+import * as React from 'react';
+export interface InputDatePickerProps extends Omit<React.ComponentPropsWithoutRef<'button'>, 'value'> {
+    /** Field label, rendered above the box. */
+    label?: React.ReactNode;
+    /** Marks the field required — appends a `*` after the label. */
+    required?: boolean;
+    /** Helper text below the box. Hidden while `error` is set. */
+    description?: React.ReactNode;
+    /** Error message below the box. Its presence switches the field to the error treatment. */
+    error?: React.ReactNode;
+    /** Single date or a start–end range. */
+    pickerType?: 'date' | 'dateRange';
+    /** Hint shown when no value is selected. */
+    placeholder?: React.ReactNode;
+    /** Formatted selected date (`pickerType="date"`). */
+    value?: React.ReactNode;
+    /** Formatted range start (`pickerType="dateRange"`). */
+    startDate?: React.ReactNode;
+    /** Formatted range end (`pickerType="dateRange"`). */
+    endDate?: React.ReactNode;
+    /** Separator between range dates. */
+    separator?: React.ReactNode;
+    /** Whether the (consumer-owned) calendar popup is open — paints the active border. */
+    open?: boolean;
+}
+declare const InputDatePicker: React.ForwardRefExoticComponent<InputDatePickerProps & React.RefAttributes<HTMLButtonElement>>;
+export { InputDatePicker };

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

@@ -0,0 +1 @@
+export { InputSearch, type InputSearchProps } from './input-search';

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

@@ -0,0 +1,10 @@
+import { SearchBoxProps } from '../search';
+import * as React from 'react';
+export interface InputSearchProps extends SearchBoxProps {
+    /** Field label, rendered above the search box. */
+    label?: React.ReactNode;
+    /** Marks the field required — appends a `*` after the label. */
+    required?: boolean;
+}
+declare const InputSearch: React.ForwardRefExoticComponent<InputSearchProps & React.RefAttributes<HTMLInputElement>>;
+export { InputSearch };

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

@@ -0,0 +1 @@
+export { InputSelect, InputSelectField, InputSelectLabel, InputSelectTrigger, InputSelectValue, InputSelectContent, InputSelectSearch, InputSelectGroup, InputSelectSection, InputSelectSectionLabel, InputSelectItem, InputSelectExpander, InputSelectDescription, InputSelectError, InputSelectStatus, useInputSelectFilter, type InputSelectItemProps, type InputSelectExpanderProps, type InputSelectStatusProps, } from './input-select';