@undevy-org/tablewright 0.1.0

package/dist/types/components/data-table/TimestampCell.d.ts

@@ -0,0 +1,3 @@
+export declare function TimestampCell({ value }: {
+    value: string | null;
+}): import("react").JSX.Element;

package/dist/types/components/data-table/TwoPanelMenu.d.ts

@@ -0,0 +1,22 @@
+export interface TwoPanelMenuItem {
+    id: string;
+    label: string;
+    checked?: boolean;
+    disabled?: boolean;
+}
+export interface TwoPanelMenuGroup {
+    key: string;
+    label: string;
+    items: TwoPanelMenuItem[];
+}
+interface TwoPanelMenuBaseProps {
+    groups: TwoPanelMenuGroup[];
+    activeCountPerGroup?: Record<string, number>;
+    trigger: React.ReactNode;
+    width?: number;
+    renderRightPanel: (group: TwoPanelMenuGroup, onClose: () => void) => React.ReactNode;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+export declare function TwoPanelMenuBase({ groups, activeCountPerGroup, trigger, width, renderRightPanel, open, onOpenChange, }: TwoPanelMenuBaseProps): import("react").JSX.Element;
+export {};

package/dist/types/components/data-table/ViewChip.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+export interface ViewChipProps extends React.HTMLAttributes<HTMLButtonElement> {
+    label: string;
+    active?: boolean;
+}
+export declare const ViewChip: React.ForwardRefExoticComponent<ViewChipProps & React.RefAttributes<HTMLButtonElement>>;

package/dist/types/components/data-table/cells/AmountCell.d.ts

@@ -0,0 +1,11 @@
+interface AmountCellProps {
+    inAmount: number;
+    inCurrency: string;
+    outAmount: number;
+    outCurrency: string;
+    inAmountConfirmed?: number;
+    outAmountConfirmed?: number;
+    mutedCurrency?: boolean;
+}
+export declare function AmountCell({ inAmount, inCurrency, outAmount, outCurrency, inAmountConfirmed, outAmountConfirmed, mutedCurrency, }: AmountCellProps): import("react").JSX.Element;
+export {};

package/dist/types/components/data-table/cells/ConfirmedAmountCell.d.ts

@@ -0,0 +1,10 @@
+interface ConfirmedAmountCellProps {
+    value: number;
+    currency: string;
+    confirmedValue?: number | null;
+    copyTitle?: string;
+    confirmedCopyTitle?: string;
+    mutedCurrency?: boolean;
+}
+export declare function ConfirmedAmountCell({ value, currency, confirmedValue, copyTitle, confirmedCopyTitle, mutedCurrency, }: ConfirmedAmountCellProps): import("react").JSX.Element;
+export {};

package/dist/types/components/data-table/cells/CurrencyAmountCell.d.ts

@@ -0,0 +1,8 @@
+interface CurrencyAmountCellProps {
+    value: number;
+    currency: string;
+    copyTitle?: string;
+    mutedCurrency?: boolean;
+}
+export declare function CurrencyAmountCell({ value, currency, copyTitle, mutedCurrency, }: CurrencyAmountCellProps): import("react").JSX.Element;
+export {};

package/dist/types/components/data-table/cells/DualLineCell.d.ts

@@ -0,0 +1,44 @@
+interface DualLineCellProps {
+    primary: string;
+    secondary: string;
+    primaryCopyTitle?: string;
+    secondaryCopyTitle?: string;
+    primaryVariant?: "default" | "mono";
+    primaryLabel?: string;
+    secondaryLabel?: string;
+    /**
+     * Controls visual weight of the secondary line.
+     *
+     * Rule of thumb:
+     * - `true` — when both lines represent **independent, equally-important
+     *   entities or operational values** (e.g. Merchant + Merchant TX ID,
+     *   Merchant Fee % + Provider Fee %, Requisite + Holder). Secondary line
+     *   uses `--text-primary` so neither side is downplayed.
+     * - `false` (default) — when the secondary line is genuinely **helper /
+     *   metadata / previous-value** (e.g. base rate type, "confirmed" amount).
+     *   Secondary line uses `--text-secondary`.
+     *
+     * Do not pick this flag based on visual position alone — pick it based on
+     * the semantic role of the secondary value.
+     */
+    equalWeight?: boolean;
+    /**
+     * Render the primary line as `start…end` when its length warrants it.
+     * Only applies to `primaryVariant="mono"`. Pass `true` for default head=6,
+     * tail=6 or supply explicit head/tail counts.
+     */
+    primaryTruncateMiddle?: boolean | {
+        head?: number;
+        tail?: number;
+    };
+    /**
+     * Render the secondary line as `start…end` when long. The secondary line is
+     * always mono, so this works regardless of the primary variant.
+     */
+    secondaryTruncateMiddle?: boolean | {
+        head?: number;
+        tail?: number;
+    };
+}
+export declare function DualLineCell({ primary, secondary, primaryCopyTitle, secondaryCopyTitle, primaryVariant, primaryLabel, secondaryLabel, equalWeight, primaryTruncateMiddle, secondaryTruncateMiddle, }: DualLineCellProps): import("react").JSX.Element;
+export {};

package/dist/types/components/data-table/cells/EnumBadgeCell.d.ts

@@ -0,0 +1,9 @@
+import type { BadgeVariant } from "../types.js";
+interface EnumBadgeCellProps {
+    value: string;
+    variantMap: Record<string, BadgeVariant>;
+    label?: string;
+    className?: string;
+}
+export declare function EnumBadgeCell({ value, variantMap, label, className }: EnumBadgeCellProps): import("react").JSX.Element;
+export {};

package/dist/types/components/data-table/cells/MonoIdCell.d.ts

@@ -0,0 +1,19 @@
+interface MonoIdCellProps {
+    value: string;
+    copyTitle?: string;
+    /** Show value as `start…end`. Default: true. */
+    truncate?: boolean;
+    /** Visible characters from the start. Default: 6. */
+    truncateHead?: number;
+    /** Visible characters from the end. Default: 6. */
+    truncateTail?: number;
+    /**
+     * Minimum length at which truncation kicks in.
+     * Default: head + tail + 2 (truncation must save at least one character).
+     * Shorter strings render in full.
+     */
+    truncateThreshold?: number;
+}
+export declare function truncateMiddle(value: string, head: number, tail: number, threshold: number): string;
+export declare function MonoIdCell({ value, copyTitle, truncate, truncateHead, truncateTail, truncateThreshold, }: MonoIdCellProps): import("react").JSX.Element;
+export {};

package/dist/types/components/data-table/filter-types.d.ts

@@ -0,0 +1,79 @@
+export type ColumnFilterType = "text" | "enum" | "date" | "number-range" | "compound";
+export interface CompoundSubFilter {
+    key: string;
+    type: "text" | "number-range" | "enum";
+    label: string;
+    badge?: string;
+    field: string;
+    options?: {
+        label: string;
+        value: string;
+    }[];
+}
+export interface ColumnFilterConfig {
+    type: ColumnFilterType;
+    label: string;
+    fieldName?: string;
+    options?: {
+        label: string;
+        value: string;
+    }[];
+    subFilters?: CompoundSubFilter[];
+}
+export type ActiveFilterValue = string | string[] | {
+    from?: string;
+    to?: string;
+} | {
+    from?: number;
+    to?: number;
+} | {
+    [key: string]: ActiveFilterValue;
+};
+export interface ActiveFilter {
+    columnId: string;
+    value: ActiveFilterValue;
+}
+export type FilterColumnStats = {
+    type: "number-range";
+    min: number;
+    max: number;
+} | {
+    type: "text";
+    samples: string[];
+    totalUnique: number;
+} | {
+    type: "date";
+    min: string;
+    max: string;
+} | {
+    type: "enum";
+    counts: Record<string, number>;
+};
+export interface FilterStatsSlice {
+    all: FilterColumnStats;
+    filtered: FilterColumnStats | null;
+}
+export interface ColumnGroup {
+    key: string;
+    label: string;
+    columnIds: string[];
+}
+export interface ColumnGap {
+    afterColumnId: string | null;
+    hiddenIds: string[];
+}
+export interface ViewPreset<TRow, TViewKey extends string> {
+    key: TViewKey;
+    label: string;
+    filters: ActiveFilter[];
+    sort: {
+        columnId: string;
+        direction: "asc" | "desc";
+    } | null;
+    columnVisibility?: Record<string, boolean>;
+    customFilter?: (row: TRow) => boolean;
+    customFilterChip?: {
+        label: string;
+        value: string;
+    };
+}

package/dist/types/components/data-table/hooks/use-column-resize.d.ts

@@ -0,0 +1,7 @@
+import type { ColumnMetaDef } from "../types.js";
+export declare function useColumnResize(defaults: Record<string, ColumnMetaDef>, initialWidths?: Record<string, number>): {
+    widths: Record<string, number>;
+    totalWidth: number;
+    onPointerDown: (colId: string, e: React.PointerEvent) => void;
+    setWidths: import("react").Dispatch<import("react").SetStateAction<Record<string, number>>>;
+};

package/dist/types/components/data-table/hooks/use-row-drag.d.ts

@@ -0,0 +1,14 @@
+export interface RowDragProps {
+    draggable: true;
+    onDragStart: (e: React.DragEvent) => void;
+    onDragOver: (e: React.DragEvent) => void;
+    onDragLeave: () => void;
+    onDrop: (e: React.DragEvent) => void;
+    onDragEnd: () => void;
+}
+export interface UseRowDragResult {
+    dragRowIdx: number | null;
+    dropTargetIdx: number | null;
+    getDragProps: (rowIndex: number) => RowDragProps;
+}
+export declare function useRowDrag<T>(source: T[], onReorder: (items: T[]) => void): UseRowDragResult;

package/dist/types/components/data-table/hooks/use-table-pagination.d.ts

@@ -0,0 +1,10 @@
+export declare function getVisiblePageNumbers(currentPage: number, totalPages: number, maxVisible?: number): number[];
+export declare function useTablePagination(totalItems: number, itemsPerPage?: number): {
+    page: number;
+    setPage: import("react").Dispatch<import("react").SetStateAction<number>>;
+    safePage: number;
+    totalPages: number;
+    pageNumbers: number[];
+    paginate: <T>(items: T[]) => T[];
+    resetPage: () => void;
+};

package/dist/types/components/data-table/hooks/use-table-sort.d.ts

@@ -0,0 +1,6 @@
+import type { SortDirection } from "../types.js";
+export declare function useTableSort(onSortChange?: () => void): {
+    sortState: Record<string, SortDirection>;
+    toggleSort: (columnId: string) => void;
+    applySorting: <T>(items: T[], getSortValue: (item: T, col: string) => string | number) => T[];
+};

package/dist/types/components/data-table/managed-filters.d.ts

@@ -0,0 +1,18 @@
+import type { ActiveFilter, ActiveFilterValue } from "./filter-types.js";
+export type ManagedFilterChange = {
+    columnId: string;
+    action: "set";
+    value: ActiveFilterValue;
+} | {
+    columnId: string;
+    action: "remove";
+};
+interface OrchSlice {
+    columnFilters: ActiveFilter[];
+    handleSetColumnFilter: (columnId: string, value: ActiveFilterValue) => void;
+    handleRemoveColumnFilter: (columnId: string) => void;
+}
+export declare function applyManagedChanges(orch: OrchSlice, changes: ManagedFilterChange[]): void;
+export declare function clearManagedFilters(orch: OrchSlice, managedColumnIds: string[]): void;
+export declare function hasActiveManagedFilters(filters: ActiveFilter[], managedFieldIds: readonly string[]): boolean;
+export {};

package/dist/types/components/data-table/sticky-utils.d.ts

@@ -0,0 +1,4 @@
+import type { CSSProperties } from "react";
+import type { ColumnMetaDef } from "./types.js";
+export declare function stickyStyle(meta: ColumnMetaDef | undefined, isHeader: boolean): CSSProperties | undefined;
+export declare function stickyBorderClass(meta: ColumnMetaDef | undefined): string;

package/dist/types/components/data-table/types.d.ts

@@ -0,0 +1,35 @@
+import type { CSSProperties } from "react";
+export type SortDirection = "asc" | "desc" | false;
+export type ViewMode = "list" | "grid";
+export type BadgeVariant = "success" | "warning" | "danger" | "info" | "neutral" | "purple" | "sky" | "indigo";
+export interface ColumnMetaDef {
+    minW: number;
+    sticky?: "left" | "right";
+    stickyOffset?: number;
+    borderEdge?: "right" | "left" | null;
+    variant?: "control";
+}
+export interface BulkAction {
+    label: string;
+    onClick: () => void;
+    variant?: "default" | "danger";
+}
+export type RowActionVariant = "default" | "danger" | "accent";
+export interface RowActionItem {
+    icon: React.ComponentType<{
+        className?: string;
+    }>;
+    label: string;
+    onClick: (e: React.MouseEvent) => void;
+    variant?: RowActionVariant;
+    disabled?: boolean;
+}
+export interface RowActionSection {
+    label: string;
+    actions: RowActionItem[];
+}
+export interface StatusConfigEntry {
+    label: string;
+    variant: BadgeVariant;
+}
+export type StickyStyleResult = CSSProperties | undefined;

package/dist/types/components/layout/AppShell.d.ts

@@ -0,0 +1,23 @@
+import * as React from "react";
+import { type SidebarProps } from "./Sidebar.js";
+import { type TopBarProps } from "./TopBar.js";
+export interface AppShellProps {
+    collapsed?: boolean;
+    defaultCollapsed?: boolean;
+    onCollapsedChange?: (next: boolean) => void;
+    children: React.ReactNode;
+    className?: string;
+}
+declare function AppShellRoot({ collapsed: controlledCollapsed, defaultCollapsed, onCollapsedChange: onCollapsedChangeProp, children, className, }: AppShellProps): React.JSX.Element;
+declare function AppShellSidebar(props: SidebarProps): React.JSX.Element;
+declare function AppShellHeader(props: TopBarProps): React.JSX.Element;
+declare function AppShellContent({ children, className, }: {
+    children: React.ReactNode;
+    className?: string;
+}): React.JSX.Element;
+export declare const AppShell: typeof AppShellRoot & {
+    Sidebar: typeof AppShellSidebar;
+    Header: typeof AppShellHeader;
+    Content: typeof AppShellContent;
+};
+export {};

package/dist/types/components/layout/Sidebar.d.ts

@@ -0,0 +1,16 @@
+import * as React from "react";
+import type { NavGroup } from "./types.js";
+export interface SidebarProps {
+    groups: NavGroup[];
+    activeKey?: string;
+    collapsed?: boolean;
+    onCollapsedChange?: (next: boolean) => void;
+    renderLink?: (href: string, props: {
+        className: string;
+        children: React.ReactNode;
+    }) => React.ReactNode;
+    header?: React.ReactNode;
+    footer?: React.ReactNode;
+    className?: string;
+}
+export declare const Sidebar: React.ForwardRefExoticComponent<SidebarProps & React.RefAttributes<HTMLElement>>;

package/dist/types/components/layout/SidebarAccountMenu.d.ts

@@ -0,0 +1,20 @@
+import type { LucideIcon } from "lucide-react";
+export interface AccountMenuItem {
+    key: string;
+    label: string;
+    icon?: LucideIcon;
+    variant?: "default" | "destructive";
+    onClick?: () => void;
+}
+export interface SidebarAccountMenuProps {
+    name: string;
+    role?: string;
+    avatarUrl?: string;
+    theme?: "light" | "dark";
+    onThemeChange?: (value: "light" | "dark") => void;
+    menuItems?: AccountMenuItem[];
+    onSignOut?: () => void;
+    collapsed?: boolean;
+    className?: string;
+}
+export declare function SidebarAccountMenu({ name, role, avatarUrl, theme, onThemeChange, menuItems, onSignOut, collapsed: collapsedProp, className, }: SidebarAccountMenuProps): import("react").JSX.Element;

package/dist/types/components/layout/SidebarUser.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+export interface SidebarUserProps {
+    name: string;
+    avatarUrl?: string;
+    collapsed?: boolean;
+    className?: string;
+}
+export declare const SidebarUser: React.ForwardRefExoticComponent<SidebarUserProps & React.RefAttributes<HTMLDivElement>>;

package/dist/types/components/layout/TopBar.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+export interface TopBarProps {
+    children?: React.ReactNode;
+    actions?: React.ReactNode;
+    className?: string;
+}
+export declare const TopBar: React.ForwardRefExoticComponent<TopBarProps & React.RefAttributes<HTMLDivElement>>;

package/dist/types/components/layout/app-shell-context.d.ts

@@ -0,0 +1,8 @@
+export interface AppShellContextValue {
+    collapsed: boolean;
+    hovering: boolean;
+    effectiveCollapsed: boolean;
+    onCollapsedChange: (next: boolean) => void;
+}
+export declare const AppShellContext: import("react").Context<AppShellContextValue | null>;
+export declare function useAppShell(): AppShellContextValue | null;

package/dist/types/components/layout/index.d.ts

@@ -0,0 +1,10 @@
+export { AppShell } from "./AppShell.js";
+export type { AppShellProps } from "./AppShell.js";
+export { Sidebar } from "./Sidebar.js";
+export type { SidebarProps } from "./Sidebar.js";
+export { TopBar } from "./TopBar.js";
+export type { TopBarProps } from "./TopBar.js";
+export { SidebarUser } from "./SidebarUser.js";
+export type { SidebarUserProps } from "./SidebarUser.js";
+export { useAppShell } from "./app-shell-context.js";
+export type { NavItem, NavGroup } from "./types.js";

package/dist/types/components/layout/types.d.ts

@@ -0,0 +1,11 @@
+import type { LucideIcon } from "lucide-react";
+export interface NavItem {
+    key: string;
+    label: string;
+    icon: LucideIcon;
+    href: string;
+}
+export interface NavGroup {
+    label: string;
+    items: NavItem[];
+}

package/dist/types/components/ui/badge.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const badgeVariants: (props?: ({
+    variant?: "success" | "warning" | "danger" | "info" | "neutral" | "purple" | "sky" | "indigo" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+}
+declare function Badge({ className, variant, ...props }: BadgeProps): React.JSX.Element;
+export { Badge, badgeVariants };

package/dist/types/components/ui/button-footer.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+export interface ButtonFooterProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    /** "stretch" (default, current behavior) | "end" (natural-width, right-aligned) */
+    align?: "stretch" | "end";
+}
+export declare function ButtonFooter({ children, className, align, ...props }: ButtonFooterProps): React.JSX.Element;

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

@@ -0,0 +1,11 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "icon" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export { Button, buttonVariants };

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

@@ -0,0 +1,4 @@
+import * as React from "react";
+import * as CheckboxPrimitive from "@radix-ui/react-checkbox";
+declare const Checkbox: React.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { Checkbox };

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

@@ -0,0 +1,92 @@
+import * as React from "react";
+declare const Command: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    label?: string;
+    shouldFilter?: boolean;
+    filter?: (value: string, search: string, keywords?: string[]) => number;
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    loop?: boolean;
+    disablePointerSelection?: boolean;
+    vimBindings?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandInput: React.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof React.InputHTMLAttributes<HTMLInputElement>> & {
+    ref?: React.Ref<HTMLInputElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React.InputHTMLAttributes<HTMLInputElement>>, "onChange" | "type" | "value"> & {
+    value?: string;
+    onValueChange?: (search: string) => void;
+} & React.RefAttributes<HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const CommandList: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    label?: string;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandEmpty: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandGroup: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>>, "heading" | "value"> & {
+    heading?: React.ReactNode;
+    value?: string;
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandItem: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React.HTMLAttributes<HTMLDivElement>>, "onSelect" | "disabled" | "value"> & {
+    disabled?: boolean;
+    onSelect?: (value: string) => void;
+    value?: string;
+    keywords?: string[];
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Command, CommandInput, CommandList, CommandEmpty, CommandGroup, CommandItem };
+export interface ComboboxOption<TValue extends string = string> {
+    value: TValue;
+    label: string;
+    description?: string;
+    disabled?: boolean;
+}
+export interface ComboboxProps<TValue extends string = string> {
+    value: TValue | null;
+    onChange: (value: TValue | null) => void;
+    options: ComboboxOption<TValue>[];
+    placeholder?: string;
+    searchPlaceholder?: string;
+    emptyText?: string;
+    disabled?: boolean;
+    /** Allow clearing the selection by clicking the selected item again. Default true. */
+    clearable?: boolean;
+    className?: string;
+    triggerClassName?: string;
+    contentClassName?: string;
+    /** Custom render of the selected label inside the trigger. */
+    renderSelected?: (option: ComboboxOption<TValue>) => React.ReactNode;
+    /** Accessible name for the trigger button (e.g. the field label). */
+    triggerAriaLabel?: string;
+}
+export declare function Combobox<TValue extends string = string>({ value, onChange, options, placeholder, searchPlaceholder, emptyText, disabled, clearable, className, triggerClassName, contentClassName, renderSelected, triggerAriaLabel, }: ComboboxProps<TValue>): React.JSX.Element;

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

@@ -0,0 +1,15 @@
+import * as React from "react";
+import * as DialogPrimitive from "@radix-ui/react-dialog";
+declare const Dialog: React.FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: React.FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogContent: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+    displayName: string;
+};
+declare const DialogTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+export { Dialog, DialogPortal, DialogOverlay, DialogTrigger, DialogClose, DialogContent, DialogHeader, DialogTitle, DialogDescription, };

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

@@ -0,0 +1,10 @@
+import * as React from "react";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+declare const DropdownMenu: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuPortal, DropdownMenuTrigger, };

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

@@ -0,0 +1,6 @@
+import * as React from "react";
+export interface InputProps extends React.ComponentProps<"input"> {
+    error?: boolean;
+}
+declare const Input: React.ForwardRefExoticComponent<Omit<InputProps, "ref"> & React.RefAttributes<HTMLInputElement>>;
+export { Input };

package/dist/types/components/ui/popover.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as PopoverPrimitive from "@radix-ui/react-popover";
+declare const Popover: React.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const PopoverAnchor: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverAnchorProps & React.RefAttributes<HTMLDivElement>>;
+declare const PopoverContent: React.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Popover, PopoverTrigger, PopoverContent, PopoverAnchor };

package/dist/types/components/ui/segmented-control.d.ts

@@ -0,0 +1,17 @@
+import * as React from "react";
+import type { LucideIcon } from "lucide-react";
+export interface SegmentedControlOption<T extends string> {
+    value: T;
+    label?: string;
+    icon?: LucideIcon;
+    /** Accessible name for icon-only options, which render no visible text. */
+    ariaLabel?: string;
+}
+export interface SegmentedControlProps<T extends string> extends Omit<React.HTMLAttributes<HTMLDivElement>, "onChange"> {
+    value: T;
+    options: readonly SegmentedControlOption<T>[];
+    onValueChange?: (value: T) => void;
+    variant?: "toolbar";
+    label?: string;
+}
+export declare function SegmentedControl<T extends string>({ value, options, onValueChange, variant, label, className, ...props }: SegmentedControlProps<T>): React.JSX.Element;