@mercury-fx/ui 2.4.0

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

@@ -0,0 +1,20 @@
+/**
+ * Shared scales + alignment maps for the Layout composition tier (mx.8.3).
+ *
+ * Token-scale props resolve to CSS custom properties (the `AspectRatio` non-color
+ * inline idiom, INV-2-legal); alignment props map to CSS Box-Alignment keywords
+ * that are valid in both flexbox and grid. No new token is defined here — these
+ * name existing `--space-*` / `--radius-*` scales.
+ */
+export type SpaceScale = "2" | "4" | "6" | "8" | "10" | "12" | "14" | "16" | "20" | "24" | "28" | "32" | "40" | "48" | "56" | "64" | "72" | "80" | "96" | "128";
+export type RadiusScale = "2" | "4" | "6" | "8" | "12" | "16" | "20" | "24" | "32" | "full";
+/** A space-scale step → its CSS custom property, e.g. `spaceVar("12")` → `"var(--space-12)"`. */
+export declare const spaceVar: (s: SpaceScale) => string;
+/** A radius-scale step → its CSS custom property, e.g. `radiusVar("8")` → `"var(--radius-8)"`. */
+export declare const radiusVar: (r: RadiusScale) => string;
+export type Align = "start" | "center" | "end" | "stretch" | "baseline";
+export type Justify = "start" | "center" | "end" | "between" | "around" | "evenly";
+/** `align` → `align-items` (Box-Alignment keywords; valid in flex + grid). */
+export declare const ALIGN: Record<Align, string>;
+/** `justify` → `justify-content` / `justify-items`. */
+export declare const JUSTIFY: Record<Justify, string>;

package/dist/components/navigation/Accordion/Accordion.d.ts

@@ -0,0 +1,17 @@
+import type { HTMLAttributes, ReactNode } from "react";
+export interface AccordionItemData {
+    value: string;
+    title: ReactNode;
+    content: ReactNode;
+    disabled?: boolean;
+}
+export interface AccordionProps extends Omit<HTMLAttributes<HTMLDivElement>, "defaultValue"> {
+    items: AccordionItemData[];
+    /** "single" (default) keeps one item open at a time; "multiple" allows many. */
+    type?: "single" | "multiple";
+    /** Initially-open value(s) for the uncontrolled accordion. */
+    defaultValue?: string | string[];
+    /** In single mode, allow the open item to collapse again. Default true. */
+    collapsible?: boolean;
+}
+export declare const Accordion: import("react").ForwardRefExoticComponent<AccordionProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/navigation/Accordion/index.d.ts

@@ -0,0 +1 @@
+export * from "./Accordion";

package/dist/components/navigation/Menubar/Menubar.d.ts

@@ -0,0 +1,53 @@
+import type { ReactNode } from "react";
+import type { IconName } from "../../foundations/Icon";
+/** One row of a {@link Menubar} submenu. `check`/`radio` carry state; a plain
+ * `item` runs `onSelect` and closes; `label`/`separator` are presentational. */
+export interface MenubarItem {
+    /** Row kind. Default `"item"`. */
+    type?: "item" | "check" | "radio" | "label" | "separator";
+    /** The row's visible text. */
+    label?: ReactNode;
+    /** Stable id — required for a `check` row's toggle state. */
+    id?: string;
+    /** The radio group's name (rows sharing it are mutually exclusive). */
+    group?: string;
+    /** The radio row's value (the selected value keys the group). */
+    value?: string;
+    /** Initial checked state for a `check`/`radio` row (thereafter uncontrolled). */
+    checked?: boolean;
+    /** A trailing key hint. */
+    shortcut?: string;
+    /** A leading icon (plain item rows). */
+    icon?: IconName;
+    /** Invoked on activation. */
+    onSelect?: () => void;
+}
+/** One top-level menu of a {@link Menubar}. */
+export interface MenubarMenu {
+    /** The bar trigger's text. */
+    label: string;
+    /** A leading icon on the bar trigger. */
+    icon?: IconName;
+    /** The submenu rows, in order. */
+    items: MenubarItem[];
+}
+export interface MenubarProps {
+    /** The top-level menus, left to right. */
+    menus: MenubarMenu[];
+    /** The check-mark ink + radio-dot fill family. Default `"iris"`. */
+    accent?: "iris" | "indigo" | "green" | "orange" | "plum" | "red";
+}
+/**
+ * Menubar — a horizontal bar of menus (a desktop-app menu strip). Each top menu
+ * opens a submenu that composes the overlay-floor: `useAnchoredPosition`
+ * (portaled, `position: fixed`) + `useDismiss` (outside-press + `Escape`, the
+ * whole bar ignored so a sibling trigger switches without a dismiss race) +
+ * `useArrowNavigation` (Up/Down within a submenu). `ArrowLeft`/`ArrowRight` on
+ * the bar move between the top triggers.
+ *
+ * a11y: the bar is `role="menubar"`; each trigger is `role="menuitem"` with
+ * `aria-haspopup="menu"` + `aria-expanded`; a submenu is `role="menu"` with
+ * `menuitem` / `menuitemcheckbox` / `menuitemradio` rows.
+ */
+export declare function Menubar({ menus, accent }: MenubarProps): import("react").JSX.Element;
+export default Menubar;

package/dist/components/navigation/Menubar/index.d.ts

@@ -0,0 +1 @@
+export * from "./Menubar";

package/dist/components/navigation/Pagination/Pagination.d.ts

@@ -0,0 +1,14 @@
+import type { HTMLAttributes, ReactNode } from "react";
+export interface PaginationProps extends Omit<HTMLAttributes<HTMLElement>, "onChange"> {
+    /** 1-based current page. */
+    page: number;
+    /** Total number of pages. */
+    count: number;
+    onPageChange: (page: number) => void;
+    /** Pages shown on each side of the current page. Default 1. */
+    siblingCount?: number;
+    size?: "sm" | "md";
+    /** Optional caption rendered under the controls (e.g. "Showing 1 – 10"). */
+    caption?: ReactNode;
+}
+export declare const Pagination: import("react").ForwardRefExoticComponent<PaginationProps & import("react").RefAttributes<HTMLElement>>;

package/dist/components/navigation/Pagination/index.d.ts

@@ -0,0 +1 @@
+export * from "./Pagination";

package/dist/components/navigation/TabNav/TabNav.d.ts

@@ -0,0 +1,38 @@
+import type { ReactNode } from "react";
+export type TabNavSize = "sm" | "md";
+export interface TabNavItem {
+    /** The item's stable value, matched against `value` to mark the active tab. */
+    value: string;
+    /** The visible label. */
+    label: ReactNode;
+    /** The navigation target. Omit for a non-navigating tab (driven by `onChange`). */
+    href?: string;
+    /** Renders the tab dimmed + non-interactive. */
+    disabled?: boolean;
+}
+export interface TabNavProps {
+    /** The tabs, in order. */
+    items: TabNavItem[];
+    /** The active tab's `value` (controlled). */
+    value: string;
+    /** Notified with the clicked tab's `value` (unless disabled). */
+    onChange?: (value: string) => void;
+    /** Density. Default `"md"`. */
+    size?: TabNavSize;
+}
+/**
+ * TabNav — link-styled navigation tabs: a `<nav>` of `<a aria-current="page">`
+ * anchors sharing an underline rail. Distinct from `Tabs`, which switches
+ * in-page panels — TabNav navigates (each tab is a real link with an `href`),
+ * so the active tab is the current *page*, not a selected panel.
+ *
+ * Controlled: `value` marks the active tab; `onChange` fires with the clicked
+ * tab's value (a disabled tab is inert — `preventDefault` + no `onChange`).
+ * Presentational — no floor, no portal, no internal state.
+ *
+ * a11y: the active anchor carries `aria-current="page"`; the `:focus-visible`
+ * ring is restored (the source prototype's `outline: none` was an a11y
+ * regression and is NOT carried over).
+ */
+export declare function TabNav({ items, value, onChange, size }: TabNavProps): import("react").JSX.Element;
+export default TabNav;

package/dist/components/navigation/TabNav/index.d.ts

@@ -0,0 +1 @@
+export * from "./TabNav";

package/dist/components/navigation/Tabs/Tabs.d.ts

@@ -0,0 +1,12 @@
+export interface Tab<T extends string> {
+    label: string;
+    value: T;
+    disabled?: boolean;
+}
+export interface TabsProps<T extends string> {
+    tabs: Tab<T>[];
+    value: T;
+    onChange?: (value: T) => void;
+    variant?: "underline" | "pills";
+}
+export declare function Tabs<T extends string>({ tabs, value, onChange, variant }: TabsProps<T>): import("react").JSX.Element;

package/dist/components/navigation/Tabs/index.d.ts

@@ -0,0 +1 @@
+export * from "./Tabs";

package/dist/components/overlay/AlertDialog/AlertDialog.d.ts

@@ -0,0 +1,33 @@
+import type { HTMLAttributes, ReactNode } from "react";
+export interface AlertDialogProps extends Omit<HTMLAttributes<HTMLDivElement>, "title"> {
+    /** Whether the confirmation is mounted + visible. Controlled. */
+    open: boolean;
+    /** The heading, wired to `aria-labelledby`. */
+    title?: ReactNode;
+    /** The prompt, wired to `aria-describedby`. */
+    description?: ReactNode;
+    /** Extra content between the description and the actions. */
+    children?: ReactNode;
+    /** The confirm action label. Default `"Confirm"`. */
+    confirmLabel?: string;
+    /** The cancel action label. Default `"Cancel"`. */
+    cancelLabel?: string;
+    /** Style the confirm action as destructive (a `Button variant="destructive"`). */
+    destructive?: boolean;
+    /** Invoked when the confirm action is pressed. */
+    onConfirm?: () => void;
+    /** Invoked on cancel, `Escape`, or the cancel action. */
+    onCancel?: () => void;
+}
+/**
+ * AlertDialog — a blocking confirmation that demands an explicit choice.
+ * `role="alertdialog"`, composing the overlay-floor minus outside-press
+ * dismiss: a backdrop press does NOT dismiss (deliberate), only `Escape` or the
+ * cancel action. Composes mx.7.1's `Heading` and the `Button` actions.
+ *
+ * a11y: `aria-modal`; title/description wired via `aria-labelledby`/
+ * `aria-describedby`; focus is trapped and lands on the confirm action on open,
+ * returning to the trigger on close.
+ */
+export declare const AlertDialog: import("react").ForwardRefExoticComponent<AlertDialogProps & import("react").RefAttributes<HTMLDivElement>>;
+export default AlertDialog;

package/dist/components/overlay/AlertDialog/index.d.ts

@@ -0,0 +1 @@
+export * from "./AlertDialog";

package/dist/components/overlay/ContextMenu/ContextMenu.d.ts

@@ -0,0 +1,40 @@
+import type { ReactNode } from "react";
+import type { IconName } from "../../foundations/Icon";
+/** One row of a {@link ContextMenu}. A plain `item` runs `onSelect` and closes;
+ * `label`/`separator` are presentational. `danger` recolours to the negative family. */
+export interface ContextMenuItem {
+    /** Row kind. Default `"item"`. */
+    type?: "item" | "label" | "separator";
+    /** The row's visible text. */
+    label?: ReactNode;
+    /** A leading icon. */
+    icon?: IconName;
+    /** A trailing key hint. */
+    shortcut?: string;
+    /** Invoked on activation. */
+    onSelect?: () => void;
+    /** Non-interactive + excluded from arrow-nav. */
+    disabled?: boolean;
+    /** Destructive action — recoloured to the negative family. */
+    danger?: boolean;
+}
+export interface ContextMenuProps {
+    /** The right-click surface — the wrapped region opens the menu at the pointer. */
+    children: ReactNode;
+    /** The menu rows, in order. */
+    items: ContextMenuItem[];
+    /** Panel width (px). Default `220`. */
+    width?: number;
+}
+/**
+ * ContextMenu — a menu opened at the pointer by a right-click on the wrapped
+ * region. Composes the overlay-floor: `useAnchoredPosition({ point })` (a
+ * pointer-anchored, viewport-clamped portaled panel) + `useDismiss` (outside-press
+ * + `Escape`) + `useArrowNavigation`. A local `scroll` listener dismisses while
+ * open (the page moving out from under a pinned menu).
+ *
+ * a11y: the panel is `role="menu"`, rows are `role="menuitem"`. `danger` rows are
+ * the sole recolour, token-based (no accent prop).
+ */
+export declare function ContextMenu({ children, items, width }: ContextMenuProps): import("react").JSX.Element;
+export default ContextMenu;

package/dist/components/overlay/ContextMenu/index.d.ts

@@ -0,0 +1 @@
+export * from "./ContextMenu";

package/dist/components/overlay/Dialog/Dialog.d.ts

@@ -0,0 +1,33 @@
+import type { HTMLAttributes, ReactNode } from "react";
+export type DialogSize = "sm" | "md" | "lg";
+export interface DialogProps extends Omit<HTMLAttributes<HTMLDivElement>, "title"> {
+    /** Whether the dialog is mounted + visible. Controlled. */
+    open: boolean;
+    /** Requested close — the backdrop press, the close control, or `Escape`. */
+    onClose?: () => void;
+    /** The heading, wired to `aria-labelledby`. */
+    title?: ReactNode;
+    /** A supporting line under the title, wired to `aria-describedby`. */
+    description?: ReactNode;
+    /** The body content. */
+    children?: ReactNode;
+    /** Trailing actions (usually a `Button` row). */
+    footer?: ReactNode;
+    /** Panel max-width: `sm` 420 · `md` 496 (default) · `lg` 640. */
+    size?: DialogSize;
+    /** Render the corner close control (`IconButton`). Default `true`. */
+    showClose?: boolean;
+}
+/**
+ * Dialog — a focused, blocking surface with a divider header, description slot,
+ * and footer actions. A richer `Modal`: monolithic (prop-driven, not
+ * composable-parts), composing the overlay-floor (`Portal` + `useFocusTrap` +
+ * `useDismiss`) and mx.7.1 (`Heading` title, `IconButton` close). It reuses the
+ * `.mx-modal` style family and layers the `.mx-dialog` delta.
+ *
+ * a11y: `role="dialog"` + `aria-modal`; the title/description are wired via
+ * `aria-labelledby`/`aria-describedby`; focus is trapped while open and returns
+ * to the trigger on close; `Escape` and a backdrop press dismiss.
+ */
+export declare const Dialog: import("react").ForwardRefExoticComponent<DialogProps & import("react").RefAttributes<HTMLDivElement>>;
+export default Dialog;

package/dist/components/overlay/Dialog/index.d.ts

@@ -0,0 +1 @@
+export * from "./Dialog";

package/dist/components/overlay/Dropdown/Dropdown.d.ts

@@ -0,0 +1,48 @@
+import type { ReactNode } from "react";
+import type { IconName } from "../../foundations/Icon";
+/** One row of a {@link Dropdown} menu. A `check` row toggles in place; a plain
+ * `item` runs `onSelect` and closes; `label`/`separator` are presentational. */
+export interface DropdownItem {
+    /** Row kind. Default `"item"`. */
+    type?: "item" | "label" | "separator" | "check";
+    /** The row's visible text (item/label/check). */
+    label?: ReactNode;
+    /** A leading icon (item rows). */
+    icon?: IconName;
+    /** A trailing key hint, e.g. `"⌘K"`. */
+    shortcut?: string;
+    /** Initial checked state for a `check` row (thereafter uncontrolled). */
+    checked?: boolean;
+    /** Stable id — required for a `check` row's toggle state. */
+    id?: string;
+    /** Invoked on activation (both `item` and `check`). */
+    onSelect?: () => void;
+    /** Non-interactive + excluded from arrow-nav. */
+    disabled?: boolean;
+}
+export interface DropdownProps {
+    /** The trigger's content — a label/icon, NOT an interactive element (Dropdown
+     * renders its own `<button>`). */
+    trigger: ReactNode;
+    /** The menu rows, in order. */
+    items: DropdownItem[];
+    /** The check-mark ink family. Default `"iris"`. */
+    accent?: "iris" | "indigo" | "green" | "orange" | "plum" | "red";
+    /** Which trigger edge the panel aligns to. Default `"start"`. */
+    align?: "start" | "end";
+    /** Panel width (px). Default `220`. */
+    width?: number;
+}
+/**
+ * Dropdown — a menu of actions anchored to a trigger. Composes the overlay-floor:
+ * `useAnchoredPosition` (portaled `position: fixed`, so it escapes overflow/
+ * stacking) + `useDismiss` (outside-press + `Escape`, the trigger ignored so
+ * re-pressing toggles) + `useArrowNavigation` (Up/Down over the rows).
+ *
+ * a11y: a real `<button>` trigger carries `aria-haspopup="menu"` +
+ * `aria-expanded`; the panel is `role="menu"`, rows are `role="menuitem"` /
+ * `role="menuitemcheckbox"`. Non-modal — focus moves into the panel on open and
+ * returns to the trigger on close, but `Tab` is NOT trapped.
+ */
+export declare function Dropdown({ trigger, items, accent, align, width }: DropdownProps): import("react").JSX.Element;
+export default Dropdown;

package/dist/components/overlay/Dropdown/index.d.ts

@@ -0,0 +1 @@
+export * from "./Dropdown";

package/dist/components/overlay/HoverCard/HoverCard.d.ts

@@ -0,0 +1,35 @@
+import type { ReactNode } from "react";
+export type HoverCardPlacement = "top" | "bottom" | "left" | "right";
+export interface HoverCardProps {
+    /**
+     * The anchor. Must be **focusable** (a `Link`/`Avatar`/`button`) so keyboard
+     * focus — not only hover — opens the card.
+     */
+    children: ReactNode;
+    /** The floating card body. */
+    content: ReactNode;
+    /** Which side the card anchors to. Default `"bottom"`. */
+    placement?: HoverCardPlacement;
+    /** Delay before opening on hover/focus (ms). Default `250`. */
+    openDelay?: number;
+    /** Delay before closing on leave/blur (ms). Default `150`. */
+    closeDelay?: number;
+    /** Card width (px). Default `280`. */
+    width?: number;
+}
+/**
+ * HoverCard — a non-modal preview card revealed on hover OR focus of its
+ * anchor. Composes the overlay-floor's `useAnchoredPosition` (portaled
+ * `position: fixed`, so it escapes any `overflow`/stacking context) with local
+ * open/close timers.
+ *
+ * Distinct from `Tooltip` (a static, CSS-only label) and `Popover`
+ * (click-triggered, dismiss-managed): it holds interactive content and stays
+ * open while the pointer is over the card. There is NO dismiss floor
+ * (outside-press/`Escape`) and NO focus trap — it is non-modal.
+ *
+ * a11y: the card is `role="dialog"`; FOCUS (not only hover) opens it, so the
+ * wrapped child must be focusable.
+ */
+export declare function HoverCard({ children, content, placement, openDelay, closeDelay, width, }: HoverCardProps): import("react").JSX.Element;
+export default HoverCard;

package/dist/components/overlay/HoverCard/index.d.ts

@@ -0,0 +1 @@
+export * from "./HoverCard";

package/dist/components/overlay/LinkPreview/LinkPreview.d.ts

@@ -0,0 +1,33 @@
+import type { ReactNode } from "react";
+export type LinkPreviewPlacement = "top" | "bottom";
+export interface LinkPreviewProps {
+    /**
+     * The anchor — typically a [Link](../../actions/Link/Link.prompt.md). Must be
+     * focusable so keyboard focus, not only hover, opens the preview.
+     */
+    children: ReactNode;
+    /** The floating preview body (a URL card, an embed, a summary). */
+    content: ReactNode;
+    /** Which side the preview anchors to. Default `"bottom"`. */
+    placement?: LinkPreviewPlacement;
+    /** Delay before opening on hover/focus (ms). Default `300`. */
+    openDelay?: number;
+    /** Preview width (px). Default `300`. */
+    width?: number;
+}
+/**
+ * LinkPreview — the URL-preview specialization of the hover-card family: a
+ * non-modal card revealed on hover OR focus of an inline anchor (a link), used
+ * to preview where a link leads. Composes the overlay-floor's
+ * `useAnchoredPosition` (portaled `position: fixed`) with local open/close
+ * timers.
+ *
+ * Unlike HoverCard there is NO `closeDelay` prop — the preview hides on a fixed
+ * 120ms grace so the pointer can bridge the gap onto the card. Non-modal: no
+ * dismiss floor, no focus trap.
+ *
+ * a11y: the card is `role="dialog"`; FOCUS (not only hover) opens it, so the
+ * wrapped child must be focusable.
+ */
+export declare function LinkPreview({ children, content, placement, openDelay, width, }: LinkPreviewProps): import("react").JSX.Element;
+export default LinkPreview;

package/dist/components/overlay/LinkPreview/index.d.ts

@@ -0,0 +1 @@
+export * from "./LinkPreview";

package/dist/components/overlay/Modal/Modal.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode } from "react";
+export interface ModalProps {
+    open: boolean;
+    onClose?: () => void;
+    title?: ReactNode;
+    footer?: ReactNode;
+    size?: "sm" | "md" | "lg";
+    children?: ReactNode;
+}
+export declare function Modal({ open, onClose, title, footer, size, children }: ModalProps): import("react").ReactPortal | null;

package/dist/components/overlay/Modal/index.d.ts

@@ -0,0 +1 @@
+export * from "./Modal";

package/dist/components/overlay/Popover/Popover.d.ts

@@ -0,0 +1,35 @@
+import type { ReactNode } from "react";
+export type PopoverPlacement = "bottom-start" | "bottom-end" | "top-start" | "top-end";
+export interface PopoverProps {
+    /**
+     * The trigger's content — pass a label or icon, NOT an interactive element:
+     * Popover renders its own `<button>`, and nesting a button inside is invalid.
+     */
+    trigger: ReactNode;
+    /** The panel content. */
+    children?: ReactNode;
+    /** Controlled open state. Omit for uncontrolled (see `defaultOpen`). */
+    open?: boolean;
+    /** Initial open state when uncontrolled. Default `false`. */
+    defaultOpen?: boolean;
+    /** Notified on every open/close (both controlled and uncontrolled). */
+    onOpenChange?: (open: boolean) => void;
+    /** Where the panel anchors relative to the trigger. Default `"bottom-start"`. */
+    placement?: PopoverPlacement;
+    /** Panel width (px). Default `280`. */
+    width?: number;
+}
+/**
+ * Popover — a floating panel anchored to a trigger, holding arbitrary
+ * interactive content. Controlled or uncontrolled. Composes the overlay-floor:
+ * `useAnchoredPosition` (portaled `position: fixed`, so it escapes any
+ * overflow/stacking context) + `useDismiss` (outside-press + `Escape`, the
+ * trigger ignored so re-pressing toggles).
+ *
+ * a11y: a real `<button>` trigger carries `aria-haspopup="dialog"` +
+ * `aria-expanded`; the panel is `role="dialog"`. Non-modal — focus moves into
+ * the panel on open and returns to the trigger on close, but `Tab` is NOT
+ * trapped (focus may leave freely).
+ */
+export declare function Popover({ trigger, children, open: openProp, defaultOpen, onOpenChange, placement, width, }: PopoverProps): import("react").JSX.Element;
+export default Popover;

package/dist/components/overlay/Popover/index.d.ts

@@ -0,0 +1 @@
+export * from "./Popover";

package/dist/components/overlay/Tooltip/Tooltip.d.ts

@@ -0,0 +1,6 @@
+import type { ReactNode } from "react";
+export interface TooltipProps {
+    content: ReactNode;
+    children: ReactNode;
+}
+export declare function Tooltip({ content, children }: TooltipProps): import("react").JSX.Element;

package/dist/components/overlay/Tooltip/index.d.ts

@@ -0,0 +1 @@
+export * from "./Tooltip";

package/dist/components/overlay/_overlay/Portal.d.ts

@@ -0,0 +1,14 @@
+import type { ReactNode } from "react";
+export interface PortalProps {
+    children: ReactNode;
+}
+/**
+ * Portal — the overlay-floor's thin `createPortal` wrapper. Mounts `children`
+ * at `document.body` so a floating surface escapes any `overflow`/stacking
+ * context of its origin subtree. The behavior floor (focus-trap · dismiss ·
+ * anchored-position) lives in `@mercury-fx/core`; `createPortal` lives here
+ * because `@mercury-fx/core` has no `react-dom` peer (mx.7.4 §4).
+ *
+ * SSR-guarded: with no `document` it renders nothing.
+ */
+export declare function Portal({ children }: PortalProps): ReactNode;

package/dist/components/selection/Checkbox/Checkbox.d.ts

@@ -0,0 +1,12 @@
+import type { ReactNode } from "react";
+export interface CheckboxProps {
+    checked?: boolean;
+    onChange?: (checked: boolean) => void;
+    label?: ReactNode;
+    indeterminate?: boolean;
+    disabled?: boolean;
+    name?: string;
+    value?: string;
+    id?: string;
+}
+export declare function Checkbox({ checked, onChange, label, indeterminate, disabled, name, value, id }: CheckboxProps): import("react").JSX.Element;

package/dist/components/selection/Checkbox/index.d.ts

@@ -0,0 +1 @@
+export * from "./Checkbox";

package/dist/components/selection/CheckboxCards/CheckboxCards.d.ts

@@ -0,0 +1,20 @@
+import type { ReactNode } from "react";
+import type { IconName } from "../../foundations/Icon";
+type Accent = "iris" | "indigo" | "green" | "orange" | "plum" | "red";
+export interface CheckboxCardsProps {
+    items: {
+        value: string;
+        label?: ReactNode;
+        description?: ReactNode;
+        icon?: IconName;
+        disabled?: boolean;
+    }[];
+    value?: string[];
+    defaultValue?: string[];
+    onChange?: (value: string[]) => void;
+    accent?: Accent;
+    columns?: number;
+    size?: "sm" | "md" | "lg";
+}
+export declare function CheckboxCards({ items, value, defaultValue, onChange, accent, columns, size, }: CheckboxCardsProps): import("react").JSX.Element;
+export {};

package/dist/components/selection/CheckboxCards/index.d.ts

@@ -0,0 +1 @@
+export * from "./CheckboxCards";

package/dist/components/selection/CheckboxGroup/CheckboxGroup.d.ts

@@ -0,0 +1,17 @@
+import type { ReactNode } from "react";
+type Accent = "iris" | "indigo" | "green" | "orange" | "plum" | "red";
+export interface CheckboxGroupProps {
+    items: {
+        value: string;
+        label?: ReactNode;
+        disabled?: boolean;
+    }[];
+    value?: string[];
+    defaultValue?: string[];
+    onChange?: (value: string[]) => void;
+    accent?: Accent;
+    orientation?: "vertical" | "horizontal";
+    disabled?: boolean;
+}
+export declare function CheckboxGroup({ items, value, defaultValue, onChange, accent, orientation, disabled, }: CheckboxGroupProps): import("react").JSX.Element;
+export {};

package/dist/components/selection/CheckboxGroup/index.d.ts

@@ -0,0 +1 @@
+export * from "./CheckboxGroup";

package/dist/components/selection/Radio/Radio.d.ts

@@ -0,0 +1,11 @@
+import type { ReactNode } from "react";
+export interface RadioProps {
+    checked?: boolean;
+    onChange?: (value: string) => void;
+    label?: ReactNode;
+    value: string;
+    name?: string;
+    disabled?: boolean;
+    id?: string;
+}
+export declare function Radio({ checked, onChange, label, value, name, disabled, id }: RadioProps): import("react").JSX.Element;

package/dist/components/selection/Radio/index.d.ts

@@ -0,0 +1 @@
+export * from "./Radio";

package/dist/components/selection/RadioCards/RadioCards.d.ts

@@ -0,0 +1,20 @@
+import type { ReactNode } from "react";
+import type { IconName } from "../../foundations/Icon";
+type Accent = "iris" | "indigo" | "green" | "orange" | "plum" | "red";
+export interface RadioCardsProps {
+    items: {
+        value: string;
+        label?: ReactNode;
+        description?: ReactNode;
+        icon?: IconName;
+        disabled?: boolean;
+    }[];
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    accent?: Accent;
+    columns?: number;
+    size?: "sm" | "md" | "lg";
+}
+export declare function RadioCards({ items, value, defaultValue, onChange, accent, columns, size, }: RadioCardsProps): import("react").JSX.Element;
+export {};

package/dist/components/selection/RadioCards/index.d.ts

@@ -0,0 +1 @@
+export * from "./RadioCards";

package/dist/components/selection/RadioGroup/RadioGroup.d.ts

@@ -0,0 +1,18 @@
+import type { ReactNode } from "react";
+type Accent = "iris" | "indigo" | "green" | "orange" | "plum" | "red";
+export interface RadioGroupProps {
+    items: {
+        value: string;
+        label?: ReactNode;
+        disabled?: boolean;
+    }[];
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    name?: string;
+    accent?: Accent;
+    orientation?: "vertical" | "horizontal";
+    disabled?: boolean;
+}
+export declare function RadioGroup({ items, value, defaultValue, onChange, name, accent, orientation, disabled, }: RadioGroupProps): import("react").JSX.Element;
+export {};

package/dist/components/selection/RadioGroup/index.d.ts

@@ -0,0 +1 @@
+export * from "./RadioGroup";