@iris-ui-kit/react 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,2964 @@
+import { ReadonlyStore, Store, MachineEvent, Machine, MachineState, Variant, Size, Placement, SpreadsheetXmlOptions } from '@iris-ui-kit/core';
+export { Align, DataSourceConfig, DataSourceController, DataSourceMode, DataSourceMutateOptions, DataSourceQuery, DataSourceState, DataViewColumn, FloatingEvent, FloatingMachine, FloatingState, GroupedViewConfig, GroupedViewState, GroupedViewStore, IrisHsva, PageItem as IrisPageItem, IrisRgba, Machine, MachineConfig, MachineEvent, MachineState, MutateOptions, NavNode, Placement, ResourceController, ResourceControllerConfig, ResourceQuery, ResourceState, RowMutateOptions, Side, Size, StateNode, Store, TabItem, TabsNav, TabsNavConfig, TabsNavState, Transition, Variant, addDays, addMonths, buildMonthMatrix, clamp01, clampDate, composeEventHandlers, createClientDataSource, createClientFetcher, createDataSource, createFloatingMachine, createGroupedView, createMachine, createResourceController, createStore, createTabsNav, endOfMonth, filterNavByAccess, findNavNode, findNavPath, firstLeaf, flattenNav, formatLocalISO, formatMonthYear, generateId, getPageRange, getWeekdayNames, hexToRgba, hsvToRgb, hsvaToRgba, isBranch, isClosable, isOutOfRange, isSameDay, isSameMonth, mergeProps, nodeAllowsRoles, rgbToHex, rgbToHsv, rgbaToHsva, startOfDay, startOfMonth, visibleNav } from '@iris-ui-kit/core';
+export { ThemeProvider, ThemeProviderProps, UseThemeReturn, useColorScheme, useDirection, useTheme, useThemeContext, useThemeOptional } from './theme.cjs';
+export { ApplySkinResult, LoadSkinOptions, ResolvedSkin, Skin, SkinBootScriptConfig, SkinCatalog, SkinCatalogConfig, SkinEngine, SkinEngineConfig, SkinError, SkinErrorCode, SkinLookup, SkinManifest, SkinManifestEntry, SkinMode, SkinPatch, SkinRegistry, SkinResolutionError, SkinStorage, SkinTokenOverrides, applySkin, builtinSkins, createSkinCatalog, createSkinEngine, createSkinRegistry, darkSkin, lightSkin, loadSkin, localStorageSkinStorage, memorySkinStorage, renderSkinStyle, resolveSkin, skinBootScript, skinError, skinToCssEntries, validateSkin } from '@iris-ui-kit/skins';
+export { SkinProvider, SkinProviderProps, UseSkinReturn, useSkin, useSkinContext, useSkinOptional } from './skins.cjs';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React from 'react';
+import { ButtonHTMLAttributes, ReactNode, CSSProperties, MouseEventHandler } from 'react';
+import { IrisIconRegistry } from '@iris-ui-kit/icons';
+export { CreateIconRegistryOptions, IrisIconNode, IrisIconRegistry, IrisIconResolver, IrisIconSet, RenderIconOptions, ThemeIconConfig, createIconRegistry, defaultIconRegistry, defaultIcons, renderIconSvg, resolveIcon, resolveThemedIcon } from '@iris-ui-kit/icons';
+export { FieldInputProps, FormContext, IrisForm, IrisFormProps, UseFieldArrayReturn, UseFieldReturn, UseFormReturn, useField, useFieldArray, useForm, useFormContext } from './form.cjs';
+export { I18nContext, IrisI18nProvider, IrisI18nProviderProps, UseI18nReturn, useI18n } from './i18n.cjs';
+export { UseAsyncResourceOptions, UseAsyncResourceReturn, UsePaginatedResourceOptions, UsePaginatedResourceReturn, useAsyncResource, usePaginatedResource } from './async.cjs';
+export { UseResourceController, useResourceController } from './resource.cjs';
+export { UseDataSource, UseGroupedView, useDataSource, useGroupedView } from './data.cjs';
+export { DATA_STATE_CLASS, DataStateNodeProps, UseDataStateReturn, __resetDataStateStyles, installDataStateStyles, useDataState, usePrefersReducedMotion } from './motion.cjs';
+export { IrisClickOutside, IrisClickOutsideProps, IrisHotkey, IrisHotkeyProps, IrisLongPress, IrisLongPressProps, IrisMovable, IrisMovableBounds, IrisMovablePosition, IrisMovableProps, IrisResizable, IrisResizableHandle, IrisResizableProps, IrisResizableSize, IrisSortable, IrisSortableProps, SORTABLE_ITEM_ATTR } from './behaviors.cjs';
+export { UndoStackReactiveState, useUndoStack } from './undo.cjs';
+export { UndoStack, UndoStackOptions, createUndoStack } from '@iris-ui-kit/core/undo';
+export { IrisContainer, IrisContainerMaxWidth, IrisContainerProps, IrisDashboardCard, IrisDashboardCardProps, IrisDashboardGrid, IrisDashboardGridProps, IrisGrid, IrisGridColumns, IrisGridProps, IrisHeaderLayout, IrisHeaderLayoutProps, IrisStack, IrisStackAlign, IrisStackDirection, IrisStackJustify, IrisStackProps } from './layouts.cjs';
+export { I as IrisSidebarLayout, a as IrisSidebarLayoutProps, b as IrisSidebarLayoutSidebarState } from './SidebarLayout-fWQRvK0a.cjs';
+export { IrisAdminBreadcrumb, IrisAdminBreadcrumbProps, IrisAdminLayout, IrisAdminLayoutMode, IrisAdminLayoutProps, IrisAdminTabs, IrisAdminTabsProps, IrisNavMenu, IrisNavMenuProps, UseAdminShellConfig, UseAdminShellReturn, UseTabsNavReturn, useAdminShell, useTabsNav } from './admin.cjs';
+export { IrisDashboardCardSpec, IrisDashboardNavItem, IrisDashboardTemplate, IrisDashboardTemplateProps, IrisLoginSubmitPayload, IrisLoginTemplate, IrisLoginTemplateProps } from './skeletons.cjs';
+export { UseDismissOptions, UseFloatingOptions, UseFloatingReturn, useDismiss, useFloating } from './floating.cjs';
+export { UseFocusTrapOptions, __getBodyScrollLockCount, __resetBodyScrollLock, useBodyScrollLock, useFocusTrap } from './modal-utils.cjs';
+export { IrisProvider, IrisProviderProps, PluginStoreContext, PluginStoreContextValue, usePlugin, usePluginStore } from './provider.cjs';
+export { IrisErrorBoundary, IrisErrorBoundaryFallbackProps, IrisErrorBoundaryProps } from './error-boundary.cjs';
+export { ApplyThemeResult, ThemeStore, ThemeStoreConfig, applyTheme, createThemeStore, getCssVar, toCssVarName } from '@iris-ui-kit/theme';
+export { ALL_TOKEN_NAMES, AnyToken, COLOR_TOKENS, ColorToken, IrisTheme, IrisThemeColors, IrisThemeRadii, IrisThemeSpacing, IrisThemeType, RADII_TOKENS, RadiusToken, SPACING_TOKENS, SpacingToken, darkTheme, lightTheme } from '@iris-ui-kit/tokens';
+import '@floating-ui/dom';
+
+/**
+ * Bridge a framework-agnostic `@iris-ui-kit/core` store into React reactivity.
+ * Uses React 18's `useSyncExternalStore` — the contract is identical to the
+ * one Vue uses via `ref + onMounted` and Solid uses via `createSignal`. The
+ * **same** store can power Button, Popover, Dialog, etc. on any framework.
+ */
+declare function useStore<T>(store: ReadonlyStore<T>): T;
+/**
+ * Subscribe to a DERIVED slice of a core store — the component re-renders only
+ * when `selector(state)` changes per `isEqual` (default `Object.is`), not on
+ * every store emission. Built on {@link Store.subscribeWith}. Inline closures
+ * for `selector`/`isEqual` are fine (captured via refs; the subscription is not
+ * re-created between renders).
+ */
+declare function useStoreSelector<T, U>(store: Store<T>, selector: (state: T) => U, isEqual?: (a: U, b: U) => boolean): U;
+
+/**
+ * Bridge a framework-agnostic `Machine` into React. Returns `[state, send]`
+ * — `state` is reactive (re-renders on transition) and `send` is stable
+ * across renders.
+ *
+ * Pass a **factory** (`() => createMachine(...)`) so each component instance
+ * gets its own machine. Internally memoised so re-renders don't re-create.
+ */
+declare function useMachine<TState extends string, TContext, TEvent extends MachineEvent>(factory: () => Machine<TState, TContext, TEvent>): [MachineState<TState, TContext>, (event: TEvent) => void];
+
+type IrisButtonVariant = Variant;
+type IrisButtonSize = Size;
+type IrisButtonType = 'button' | 'submit' | 'reset';
+
+interface IrisButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'type' | 'disabled' | 'onClick' | 'className' | 'style' | 'children'> {
+    variant?: IrisButtonVariant;
+    size?: IrisButtonSize;
+    disabled?: boolean;
+    loading?: boolean;
+    type?: IrisButtonType;
+    asChild?: boolean;
+    leading?: ReactNode;
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+    onClick?: MouseEventHandler<HTMLElement>;
+}
+/**
+ * React port of `IrisButton`. Same prop contract as `@iris-ui-kit/vue`'s
+ * version. **No business logic is duplicated** — the `composeEventHandlers`
+ * helper, variant token map, and singleton stylesheet are all from
+ * `@iris-ui-kit/core` / a near-identical CSS file.
+ *
+ * Validates the React-readiness promise: any future primitive can be ported
+ * by writing a thin .tsx wrapper around the same shared logic.
+ *
+ * @example
+ *   <IrisButton variant="solid" onClick={() => save()}>
+ *     Save
+ *   </IrisButton>
+ */
+declare function IrisButton({ variant, size, disabled, loading, type, asChild, leading, children, className, style, onClick, ...rest }: IrisButtonProps): react_jsx_runtime.JSX.Element | null;
+
+type IrisBadgeVariant = 'solid' | 'outline' | 'subtle';
+type IrisBadgeTone = 'primary' | 'success' | 'warning' | 'danger' | 'neutral';
+type IrisBadgeSize = 'sm' | 'md';
+interface IrisBadgeProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, 'children'> {
+    variant?: IrisBadgeVariant;
+    tone?: IrisBadgeTone;
+    size?: IrisBadgeSize;
+    children?: React.ReactNode;
+}
+/**
+ * React port of {@link import('@iris-ui-kit/vue').IrisBadge}. Same visual model.
+ *
+ * @example
+ *   <IrisBadge tone="success" variant="subtle">Active</IrisBadge>
+ */
+declare function IrisBadge({ variant, tone, size, style, children, ...rest }: IrisBadgeProps): React.ReactElement;
+
+type IrisAvatarShape = 'circle' | 'square';
+type IrisAvatarSize = 'sm' | 'md' | 'lg' | number;
+interface IrisAvatarProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, 'children'> {
+    src?: string;
+    alt?: string;
+    /** Used to derive initials when no `fallback` slot is supplied. */
+    name?: string;
+    /** Explicit fallback string; wins over derived initials. */
+    fallback?: string;
+    /** Custom fallback content (React node). */
+    fallbackContent?: React.ReactNode;
+    size?: IrisAvatarSize;
+    shape?: IrisAvatarShape;
+}
+/**
+ * React port of {@link import('@iris-ui-kit/vue').IrisAvatar}.
+ *
+ * @example
+ *   <IrisAvatar src="/me.png" name="Ada Lovelace" size="md" />
+ */
+declare function IrisAvatar({ src, alt, name, fallback, fallbackContent, size, shape, style, ...rest }: IrisAvatarProps): React.ReactElement;
+
+type IrisSpinnerSize = 'sm' | 'md' | 'lg' | number;
+interface IrisSpinnerProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, 'children'> {
+    size?: IrisSpinnerSize;
+    color?: string;
+    strokeWidth?: number;
+    label?: string;
+}
+/** React port of {@link import('@iris-ui-kit/vue').IrisSpinner}. */
+declare function IrisSpinner({ size, color, strokeWidth, label, style, ...rest }: IrisSpinnerProps): React.ReactElement;
+
+declare const __SPINNER_STYLE_ID = "iris-spinner-styles";
+declare function __resetSpinnerStyles(): void;
+
+interface IrisIconProps extends Omit<React.SVGAttributes<SVGSVGElement>, 'name' | 'children' | 'dangerouslySetInnerHTML' | 'fill'> {
+    /** Semantic icon name resolved via the registry (e.g. 'check', 'chevron-down'). */
+    name: string;
+    /** Width & height (number → px). Default 24. */
+    size?: number | string;
+    /** Stroke width for line icons. Default 2. */
+    strokeWidth?: number;
+    /** Render as a filled glyph instead of a stroked line icon. */
+    fill?: boolean;
+    /** Accessible title; sets `role="img"` + `aria-label`. Omit for decorative icons. */
+    title?: string;
+    /** Registry to resolve `name` against. Defaults to the built-in set. */
+    registry?: IrisIconRegistry;
+}
+/**
+ * Renders a registered icon as inline SVG. Resolves `name` through an
+ * `@iris-ui-kit/icons` registry and renders the icon's structured nodes as real
+ * SVG child elements (no raw-HTML injection). Colors follow `currentColor`, so
+ * the surrounding CSS `color` themes it. Renders nothing for an unresolved name.
+ */
+declare function IrisIcon({ name, size, strokeWidth, fill, title, registry, style, ...rest }: IrisIconProps): React.ReactElement | null;
+
+type IrisCardVariant = 'elevated' | 'outline' | 'subtle';
+type IrisCardPadding = 'none' | 'sm' | 'md' | 'lg';
+interface IrisCardProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    variant?: IrisCardVariant;
+    padding?: IrisCardPadding;
+    hover?: boolean;
+    header?: React.ReactNode;
+    footer?: React.ReactNode;
+    children?: React.ReactNode;
+}
+/**
+ * React port of {@link import('@iris-ui-kit/vue').IrisCard}.
+ *
+ * @example
+ *   <IrisCard variant="elevated" header={<h3>Title</h3>}>
+ *     Card body content.
+ *   </IrisCard>
+ */
+declare function IrisCard({ variant, padding, hover, header, footer, children, style, ...rest }: IrisCardProps): React.ReactElement;
+
+type IrisSkeletonShape = 'rect' | 'circle' | 'text';
+interface IrisSkeletonProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    width?: string | number;
+    height?: string | number;
+    shape?: IrisSkeletonShape;
+    animated?: boolean;
+}
+/**
+ * A placeholder shape that pulses to indicate content is loading. Supports
+ * `rect`, `circle`, and `text` shapes with configurable dimensions. Its
+ * shimmer animation respects `prefers-reduced-motion`.
+ */
+declare function IrisSkeleton({ width, height, shape, animated, style, ...rest }: IrisSkeletonProps): React.ReactElement;
+
+declare const __SKELETON_STYLE_ID = "iris-skeleton-styles";
+declare function __resetSkeletonStyles(): void;
+
+type IrisProgressTone = 'primary' | 'success' | 'warning' | 'danger';
+type IrisProgressSize = 'sm' | 'md';
+interface IrisProgressProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    value?: number | null;
+    max?: number;
+    indeterminate?: boolean;
+    tone?: IrisProgressTone;
+    size?: IrisProgressSize;
+}
+/**
+ * A horizontal progress bar. Supports determinate mode (controlled `value`)
+ * and indeterminate (indefinite animation) for ongoing operations. Customisable
+ * via `tone` and `size` props; renders `role="progressbar"`.
+ */
+declare function IrisProgress({ value, max, indeterminate, tone, size, style, ...rest }: IrisProgressProps): React.ReactElement;
+
+declare const __PROGRESS_STYLE_ID = "iris-progress-styles";
+declare function __resetProgressStyles(): void;
+
+type IrisAlertTone = 'info' | 'success' | 'warning' | 'danger';
+interface IrisAlertProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title'> {
+    tone?: IrisAlertTone;
+    title?: React.ReactNode;
+    closable?: boolean;
+    open?: boolean;
+    onClose?: () => void;
+    icon?: React.ReactNode;
+    children?: React.ReactNode;
+}
+/**
+ * React port of {@link import('@iris-ui-kit/vue').IrisAlert}.
+ *
+ * @example
+ *   <IrisAlert tone="warning" title="Heads up" closable onClose={dismiss}>
+ *     Your session expires soon.
+ *   </IrisAlert>
+ */
+declare function IrisAlert({ tone, title, closable, open, onClose, icon, children, style, ...rest }: IrisAlertProps): React.ReactElement | null;
+
+type IrisChipVariant = 'solid' | 'outline' | 'subtle';
+type IrisChipTone = 'primary' | 'success' | 'warning' | 'danger' | 'neutral';
+type IrisChipSize = 'sm' | 'md';
+interface IrisChipProps extends Omit<React.HTMLAttributes<HTMLElement>, 'onClick' | 'children'> {
+    variant?: IrisChipVariant;
+    tone?: IrisChipTone;
+    size?: IrisChipSize;
+    closable?: boolean;
+    clickable?: boolean;
+    disabled?: boolean;
+    onClose?: () => void;
+    onClick?: (event: React.MouseEvent<HTMLElement>) => void;
+    icon?: React.ReactNode;
+    children?: React.ReactNode;
+}
+/** React port of {@link import('@iris-ui-kit/vue').IrisChip}. */
+declare function IrisChip({ variant, tone, size, closable, clickable, disabled, onClose, onClick, icon, children, style, ...rest }: IrisChipProps): React.ReactElement;
+
+type IrisKbdSize = 'sm' | 'md';
+interface IrisKbdProps extends Omit<React.HTMLAttributes<HTMLElement>, 'children'> {
+    keys?: string | string[];
+    separator?: string;
+    size?: IrisKbdSize;
+    children?: React.ReactNode;
+}
+/** React port of {@link import('@iris-ui-kit/vue').IrisKbd}. */
+declare function IrisKbd({ keys, separator, size, children, style, ...rest }: IrisKbdProps): React.ReactElement | null;
+
+type IrisDividerOrientation = 'horizontal' | 'vertical';
+type IrisDividerSpacing = 'sm' | 'md' | 'lg';
+interface IrisDividerProps extends Omit<React.HTMLAttributes<HTMLElement>, 'children'> {
+    orientation?: IrisDividerOrientation;
+    label?: React.ReactNode;
+    spacing?: IrisDividerSpacing;
+    children?: React.ReactNode;
+}
+/** React port of {@link import('@iris-ui-kit/vue').IrisDivider}. */
+declare function IrisDivider({ orientation, label, spacing, children, style, ...rest }: IrisDividerProps): React.ReactElement;
+
+interface IrisEmptyStateProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title' | 'children'> {
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    icon?: React.ReactNode;
+    action?: React.ReactNode;
+    children?: React.ReactNode;
+}
+/** React port of {@link import('@iris-ui-kit/vue').IrisEmptyState}. */
+declare function IrisEmptyState({ title, description, icon, action, children, style, ...rest }: IrisEmptyStateProps): React.ReactElement;
+
+type IrisInputSize = 'sm' | 'md' | 'lg';
+type IrisInputType = 'text' | 'password' | 'email' | 'number' | 'search' | 'tel' | 'url';
+interface IrisInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size' | 'type' | 'prefix'> {
+    size?: IrisInputSize;
+    type?: IrisInputType;
+    invalid?: boolean;
+    /** Forwarded as aria-describedby. */
+    ariaDescribedby?: string;
+    prefix?: React.ReactNode;
+    suffix?: React.ReactNode;
+}
+/**
+ * Single-line text input with size variants, an `invalid` state, and optional
+ * `prefix`/`suffix` adornments. Forwards its ref to the native `<input>`.
+ *
+ * @example
+ *   <IrisInput value={name} onChange={(e) => setName(e.target.value)} placeholder="Name" />
+ */
+declare const IrisInput: React.ForwardRefExoticComponent<IrisInputProps & React.RefAttributes<HTMLInputElement>>;
+
+type IrisTextareaSize = 'sm' | 'md' | 'lg';
+interface IrisTextareaProps extends Omit<React.TextareaHTMLAttributes<HTMLTextAreaElement>, 'size'> {
+    size?: IrisTextareaSize;
+    invalid?: boolean;
+    ariaDescribedby?: string;
+    autosize?: boolean;
+    maxRows?: number;
+}
+/**
+ * Multi-line text input with size variants and an `invalid` state. Optionally
+ * grows to fit its content when `autosize` is set, capped at `maxRows`.
+ *
+ * @example
+ *   <IrisTextarea value={bio} onChange={(e) => setBio(e.target.value)} autosize maxRows={6} />
+ */
+declare const IrisTextarea: React.ForwardRefExoticComponent<IrisTextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+
+type IrisSwitchSize = 'sm' | 'md' | 'lg';
+interface IrisSwitchProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'type' | 'size' | 'value' | 'checked' | 'onChange'> {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onChange?: (next: boolean, event: React.ChangeEvent<HTMLInputElement>) => void;
+    size?: IrisSwitchSize;
+    invalid?: boolean;
+    ariaDescribedby?: string;
+}
+/**
+ * Toggle switch for an on/off boolean, in controlled (`checked`) or
+ * uncontrolled (`defaultChecked`) modes. Rendered with `role="switch"`.
+ *
+ * @example
+ *   <IrisSwitch checked={enabled} onChange={(next) => setEnabled(next)} />
+ */
+declare const IrisSwitch: React.ForwardRefExoticComponent<IrisSwitchProps & React.RefAttributes<HTMLInputElement>>;
+
+type IrisCheckboxSize = 'sm' | 'md' | 'lg';
+type IrisCheckboxValue = boolean | 'indeterminate';
+interface IrisCheckboxProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'type' | 'size' | 'value' | 'checked' | 'defaultChecked' | 'onChange'> {
+    /** `true`, `false`, or `'indeterminate'`. */
+    checked?: IrisCheckboxValue;
+    defaultChecked?: IrisCheckboxValue;
+    onChange?: (next: boolean, event: React.ChangeEvent<HTMLInputElement>) => void;
+    size?: IrisCheckboxSize;
+    invalid?: boolean;
+    ariaDescribedby?: string;
+    /** Label content rendered next to the box. */
+    children?: React.ReactNode;
+}
+/**
+ * Tri-state checkbox supporting `true`, `false`, and `'indeterminate'`, in both
+ * controlled (`checked`) and uncontrolled (`defaultChecked`) modes.
+ *
+ * @example
+ *   <IrisCheckbox checked={agreed} onChange={(next) => setAgreed(next)}>
+ *     I agree to the terms
+ *   </IrisCheckbox>
+ */
+declare const IrisCheckbox: React.ForwardRefExoticComponent<IrisCheckboxProps & React.RefAttributes<HTMLInputElement>>;
+
+interface IrisPasswordInputProps extends Omit<IrisInputProps, 'type' | 'prefix' | 'suffix' | 'children'> {
+    /** Allow toggling visibility. Default true. */
+    showToggle?: boolean;
+    /** Custom suffix slot (rendered before the toggle). */
+    suffix?: React.ReactNode;
+    /** Custom prefix slot. */
+    prefix?: React.ReactNode;
+}
+/** React port of {@link import('@iris-ui-kit/vue').IrisPasswordInput}. */
+declare const IrisPasswordInput: React.ForwardRefExoticComponent<IrisPasswordInputProps & React.RefAttributes<HTMLInputElement>>;
+
+type IrisNumberInputSize = 'sm' | 'md' | 'lg';
+interface IrisNumberInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'type' | 'size' | 'value' | 'defaultValue' | 'onChange' | 'min' | 'max' | 'step'> {
+    value?: number | null;
+    defaultValue?: number | null;
+    onChange?: (next: number | null) => void;
+    size?: IrisNumberInputSize;
+    min?: number;
+    max?: number;
+    step?: number;
+    invalid?: boolean;
+    showControls?: boolean;
+    ariaDescribedby?: string;
+}
+/** React port of {@link import('@iris-ui-kit/vue').IrisNumberInput}. */
+declare const IrisNumberInput: React.ForwardRefExoticComponent<IrisNumberInputProps & React.RefAttributes<HTMLInputElement>>;
+
+type IrisOtpInputSize = 'sm' | 'md' | 'lg';
+type IrisOtpInputType = 'numeric' | 'alphanumeric';
+interface IrisOtpInputProps {
+    /** Controlled value (the full code). */
+    value?: string;
+    /** Initial value when uncontrolled. */
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    /** Fired once the code fills every cell. */
+    onComplete?: (value: string) => void;
+    /** Number of cells. Default 6. */
+    length?: number;
+    /** Allowed characters: digits only, or digits + letters. */
+    type?: IrisOtpInputType;
+    /** Mask entered characters (renders password cells). */
+    mask?: boolean;
+    size?: IrisOtpInputSize;
+    disabled?: boolean;
+    invalid?: boolean;
+    autoFocus?: boolean;
+    /** Placeholder glyph shown in empty cells. */
+    placeholder?: string;
+    /** id forwarded to the first cell so `<label htmlFor>` focuses it. Set by `IrisFormField`. */
+    id?: string;
+    /** Applied as `aria-describedby` on every cell. Set by `IrisFormField`. */
+    ariaDescribedby?: string;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * One-time-code / PIN entry: a row of single-character cells with smart focus
+ * movement, paste-to-fill, and keyboard editing. The value is kept contiguous
+ * (no interior gaps), masked optionally, and surfaced via `onValueChange`;
+ * `onComplete` fires when every cell is filled. Drop it inside `IrisFormField`
+ * — the injected `id` lands on the first cell so the label focuses it.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisOtpInput}.
+ */
+declare function IrisOtpInput({ value: valueProp, defaultValue, onValueChange, onComplete, length, type, mask, size, disabled, invalid, autoFocus, placeholder, id, ariaDescribedby, style, className, }: IrisOtpInputProps): React.ReactElement;
+
+type IrisRatingSize = 'sm' | 'md' | 'lg';
+interface IrisRatingProps {
+    /** Controlled rating (0..max, in 0.5 steps when `allowHalf`). */
+    value?: number;
+    /** Initial value when uncontrolled. */
+    defaultValue?: number;
+    onValueChange?: (value: number) => void;
+    /** Number of stars. Default 5. */
+    max?: number;
+    /** Allow half-star precision. */
+    allowHalf?: boolean;
+    /** Display-only — no interaction. */
+    readonly?: boolean;
+    disabled?: boolean;
+    /** Clicking the current value again resets to 0. Default true. */
+    clearable?: boolean;
+    size?: IrisRatingSize;
+    invalid?: boolean;
+    /** Accessible label for the slider. */
+    label?: string;
+    /** id forwarded to the slider. Set by `IrisFormField`. */
+    id?: string;
+    /** Applied as `aria-describedby`. Set by `IrisFormField`. */
+    ariaDescribedby?: string;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Star rating with optional half-star precision, hover preview, keyboard
+ * support, and a `readonly` display mode. Uses the `slider` ARIA pattern
+ * (`aria-valuemin/now/max` + arrow keys) so it reads correctly to assistive
+ * tech; stars are decorative. RTL-safe via logical fill clipping.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisRating}.
+ */
+declare function IrisRating({ value: valueProp, defaultValue, onValueChange, max, allowHalf, readonly, disabled, clearable, size, invalid, label, id, ariaDescribedby, style, className, }: IrisRatingProps): React.ReactElement;
+
+type IrisComboboxSize = 'sm' | 'md' | 'lg';
+interface IrisComboboxOption {
+    label: string;
+    value: string;
+    disabled?: boolean;
+}
+interface IrisComboboxProps {
+    /** Controlled selected option value ('' = none). */
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    options: IrisComboboxOption[];
+    placeholder?: string;
+    disabled?: boolean;
+    invalid?: boolean;
+    size?: IrisComboboxSize;
+    /** Text shown when no option matches the query. Defaults to the i18n value. */
+    emptyText?: string;
+    /** id forwarded to the input. Set by `IrisFormField`. */
+    id?: string;
+    /** Applied as `aria-describedby` on the input. Set by `IrisFormField`. */
+    ariaDescribedby?: string;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Filterable single-select (searchable select): a text input that type-ahead
+ * filters a listbox of options. The displayed text is derived
+ * (`filtering ? query : selected label`) so controlled value changes stay in
+ * sync without an effect. Opens downward; follows the ARIA 1.2 combobox pattern.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisCombobox}.
+ */
+declare function IrisCombobox({ value: valueProp, defaultValue, onValueChange, options, placeholder, disabled, invalid, size, emptyText, id, ariaDescribedby, style, className, }: IrisComboboxProps): React.ReactElement;
+
+type IrisTimelineVariant = 'default' | 'success' | 'warning' | 'danger' | 'info';
+interface IrisTimelineItem {
+    /** Stable key; falls back to the index. */
+    key?: string | number;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    /** Timestamp / meta line shown above the title. */
+    time?: React.ReactNode;
+    /** Dot variant (maps to a theme color). */
+    variant?: IrisTimelineVariant;
+    /** Explicit dot color, overriding `variant`. */
+    color?: string;
+}
+interface IrisTimelineProps {
+    items: IrisTimelineItem[];
+    /** Replace the default content (time/title/description) for every item. */
+    renderItem?: (item: IrisTimelineItem, index: number) => React.ReactNode;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Vertical event timeline: an ordered list of items, each with a colored dot,
+ * a connector line (omitted on the last item), and time/title/description
+ * content (or a custom `renderItem`). Semantic `<ol>` for assistive tech;
+ * RTL-safe via logical properties.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisTimeline}.
+ */
+declare function IrisTimeline({ items, renderItem, style, className, }: IrisTimelineProps): React.ReactElement;
+
+interface IrisCarouselProps {
+    /** Each child is a slide. */
+    children: React.ReactNode;
+    /** Controlled active slide index. */
+    index?: number;
+    defaultIndex?: number;
+    onIndexChange?: (index: number) => void;
+    /** Wrap around at the ends (default true). */
+    loop?: boolean;
+    /** Auto-advance slides. Disabled when the user prefers reduced motion. */
+    autoplay?: boolean;
+    /** Autoplay interval in ms (default 4000). */
+    interval?: number;
+    /** Pause autoplay while hovered (default true). */
+    pauseOnHover?: boolean;
+    showArrows?: boolean;
+    showIndicators?: boolean;
+    /** Accessible name for the carousel region. */
+    ariaLabel?: string;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Slide carousel: shows one child slide at a time with prev/next controls,
+ * indicator dots, and keyboard (←/→) navigation. Controlled or uncontrolled.
+ * a11y: region with `aria-roledescription="carousel"`, per-slide labelling,
+ * and a polite live region announcing the active slide.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisCarousel}.
+ */
+declare function IrisCarousel({ children, index: indexProp, defaultIndex, onIndexChange, loop, autoplay, interval, pauseOnHover, showArrows, showIndicators, ariaLabel, style, className, }: IrisCarouselProps): React.ReactElement;
+
+type IrisStatisticSize = 'sm' | 'md' | 'lg';
+type IrisStatisticTrend = 'up' | 'down' | 'neutral';
+interface IrisStatisticProps {
+    label?: React.ReactNode;
+    value: React.ReactNode;
+    /** Rendered before the value (e.g. a currency sign). */
+    prefix?: React.ReactNode;
+    /** Rendered after the value (e.g. a unit). */
+    suffix?: React.ReactNode;
+    description?: React.ReactNode;
+    /** Trend direction — colors the trend line and shows a ▲/▼ glyph. */
+    trend?: IrisStatisticTrend;
+    /** Trend magnitude text (e.g. "12%"). */
+    trendValue?: React.ReactNode;
+    size?: IrisStatisticSize;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Compact statistic / KPI display: a label, a prominent value (with optional
+ * prefix/suffix), an optional colored trend line, and a description. Pure
+ * presentation; the trend glyph is decorative (aria-hidden) — the magnitude
+ * text carries the meaning.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisStatistic}.
+ */
+declare function IrisStatistic({ label, value, prefix, suffix, description, trend, trendValue, size, style, className, }: IrisStatisticProps): React.ReactElement;
+
+type IrisDescriptionsLayout = 'horizontal' | 'vertical';
+interface IrisDescriptionsItem {
+    key?: string | number;
+    label: React.ReactNode;
+    value: React.ReactNode;
+}
+interface IrisDescriptionsProps {
+    items: IrisDescriptionsItem[];
+    /** Number of label/value pairs per row. Default 1. */
+    columns?: number;
+    /** `horizontal` = label beside value; `vertical` = label above value. */
+    layout?: IrisDescriptionsLayout;
+    /** Boxed style with cell separators. */
+    bordered?: boolean;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Description list: a semantic `<dl>` rendering label/value pairs in a grid.
+ * `columns` controls pairs-per-row, `layout` places the label beside or above
+ * the value, and `bordered` draws a boxed style with separators. RTL-safe via
+ * logical properties.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisDescriptions}.
+ */
+declare function IrisDescriptions({ items, columns, layout, bordered, style, className, }: IrisDescriptionsProps): React.ReactElement;
+
+interface IrisTransferItem {
+    label: string;
+    value: string;
+    disabled?: boolean;
+}
+interface IrisTransferProps {
+    options: IrisTransferItem[];
+    /** Values currently in the target (selected) pane. */
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (values: string[]) => void;
+    /** Pane titles: [available, selected]. */
+    titles?: [React.ReactNode, React.ReactNode];
+    /** Show a search box per pane. */
+    searchable?: boolean;
+    disabled?: boolean;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Dual-list transfer: move items between an "available" and a "selected" pane
+ * via per-item checkboxes and the ›/‹ buttons. Controlled or uncontrolled
+ * (`value` = the selected values), with optional per-pane search and a
+ * select-all header. Built on native checkboxes for accessibility.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisTransfer}.
+ */
+declare function IrisTransfer({ options, value: valueProp, defaultValue, onValueChange, titles, searchable, disabled, style, className, }: IrisTransferProps): React.ReactElement;
+
+interface IrisWatermarkProps {
+    /** Watermark text, tiled across the area. */
+    content: string;
+    /** Content the watermark overlays. */
+    children?: React.ReactNode;
+    /** Rotation of each tile in degrees. */
+    rotate?: number;
+    fontSize?: number;
+    color?: string;
+    /** Overlay opacity (0–1). */
+    opacity?: number;
+    /** Spacing between tiles in px. */
+    gap?: number;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Watermark: overlays tiled, rotated text over its content — for confidential
+ * or branded surfaces. The overlay is `aria-hidden`, non-selectable, and
+ * `pointer-events: none`, so it never interferes with the underlying UI. Built
+ * from structured `<span>` nodes (no raw HTML / canvas / SVG-string injection).
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisWatermark}.
+ */
+declare function IrisWatermark({ content, children, rotate, fontSize, color, opacity, gap, style, className, }: IrisWatermarkProps): React.ReactElement;
+
+interface IrisBackTopProps {
+    /** Scroll container resolver. Defaults to the window. */
+    target?: () => HTMLElement | Window | null;
+    /** Show the button once the scroll position passes this (px). */
+    visibilityHeight?: number;
+    /** Scroll behavior; forced to 'auto' under reduced motion. */
+    behavior?: ScrollBehavior;
+    onClick?: () => void;
+    ariaLabel?: string;
+    children?: React.ReactNode;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Back-to-top button: appears once the scroll target passes `visibilityHeight`
+ * and scrolls it back to the top on click (honoring reduced motion). Defaults
+ * to the window; pass `target` for a scrollable container.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisBackTop}.
+ */
+declare function IrisBackTop({ target, visibilityHeight, behavior, onClick, ariaLabel, children, style, className, }: IrisBackTopProps): React.ReactElement | null;
+
+interface IrisAffixProps {
+    /** Pin this many px from the top once scrolled past. */
+    offsetTop?: number;
+    /** Pin this many px from the bottom (used when `offsetTop` is unset). */
+    offsetBottom?: number;
+    /** Scroll container resolver. Defaults to the window. */
+    target?: () => HTMLElement | Window | null;
+    onChange?: (affixed: boolean) => void;
+    children: React.ReactNode;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Affix: pins its content to the viewport once the user scrolls past it.
+ * Top mode (`offsetTop`) or bottom mode (`offsetBottom`); the placeholder
+ * reserves the content's height so the page doesn't jump when it detaches.
+ * `onChange` fires only when the affixed state flips.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisAffix}.
+ */
+declare function IrisAffix({ offsetTop, offsetBottom, target, onChange, children, style, className, }: IrisAffixProps): React.ReactElement;
+
+type IrisResultStatus = 'success' | 'error' | 'info' | 'warning';
+interface IrisResultProps {
+    status?: IrisResultStatus;
+    title?: React.ReactNode;
+    subtitle?: React.ReactNode;
+    /** Override the default status glyph/icon. */
+    icon?: React.ReactNode;
+    /** Action area (e.g. buttons) below the text. */
+    extra?: React.ReactNode;
+    /** Additional content (e.g. error details). */
+    children?: React.ReactNode;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Result: a centered outcome page for an operation — a status icon, title,
+ * subtitle, action area, and optional content. Use for success / error / 404 /
+ * 403 / 500 screens. Pure presentation; the status glyph is decorative.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisResult}.
+ */
+declare function IrisResult({ status, title, subtitle, icon, extra, children, style, className, }: IrisResultProps): React.ReactElement;
+
+type IrisTreeSelectSize = 'sm' | 'md' | 'lg';
+interface IrisTreeSelectNode {
+    label: string;
+    value: string;
+    disabled?: boolean;
+    children?: IrisTreeSelectNode[];
+}
+interface IrisTreeSelectProps {
+    options: IrisTreeSelectNode[];
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    /** Node values expanded by default. */
+    defaultExpanded?: string[];
+    placeholder?: string;
+    disabled?: boolean;
+    invalid?: boolean;
+    size?: IrisTreeSelectSize;
+    /** id forwarded to the trigger. Set by `IrisFormField`. */
+    id?: string;
+    ariaDescribedby?: string;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Hierarchical single-select: a trigger that opens a `role="tree"` dropdown
+ * with expand/collapse toggles. Selecting a node sets the value and closes.
+ * Controlled or uncontrolled; closes on select, Escape, or outside click.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisTreeSelect}.
+ */
+declare function IrisTreeSelect({ options, value, defaultValue, onValueChange, defaultExpanded, placeholder, disabled, invalid, size, id, ariaDescribedby, style, className, }: IrisTreeSelectProps): React.ReactElement;
+
+interface IrisMentionOption {
+    label: string;
+    value: string;
+}
+interface IrisMentionsProps {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    options: IrisMentionOption[];
+    /** Trigger character. Default '@'. */
+    prefix?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    invalid?: boolean;
+    rows?: number;
+    /** id forwarded to the textarea. Set by `IrisFormField`. */
+    id?: string;
+    ariaDescribedby?: string;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Mentions: a textarea that opens an autocomplete listbox when the user types
+ * the trigger character (default `@`). Selecting a suggestion replaces the
+ * `@query` token with the chosen label. Keyboard: ↑/↓ to move, Enter to pick,
+ * Esc to dismiss.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisMentions}.
+ */
+declare function IrisMentions({ value, defaultValue, onValueChange, options, prefix, placeholder, disabled, invalid, rows, id, ariaDescribedby, style, className, }: IrisMentionsProps): React.ReactElement;
+
+type IrisCascaderSize = 'sm' | 'md' | 'lg';
+interface IrisCascaderNode {
+    label: string;
+    value: string;
+    disabled?: boolean;
+    children?: IrisCascaderNode[];
+}
+interface IrisCascaderProps {
+    options: IrisCascaderNode[];
+    /** Selected path of values. */
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (path: string[]) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    invalid?: boolean;
+    /** Separator between path labels in the trigger. */
+    separator?: string;
+    size?: IrisCascaderSize;
+    id?: string;
+    ariaDescribedby?: string;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Cascader: a hierarchical select that drills down through columns — choosing a
+ * branch reveals its children in the next column; choosing a leaf commits the
+ * full path. Controlled or uncontrolled; closes on leaf-select, Escape, or
+ * outside click.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisCascader}.
+ */
+declare function IrisCascader({ options, value, defaultValue, onValueChange, placeholder, disabled, invalid, separator, size, id, ariaDescribedby, style, className, }: IrisCascaderProps): React.ReactElement;
+
+type IrisSegmentedSize = 'sm' | 'md' | 'lg';
+interface IrisSegmentedOption {
+    label: string;
+    value: string;
+    disabled?: boolean;
+}
+interface IrisSegmentedProps {
+    options: Array<IrisSegmentedOption | string>;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    size?: IrisSegmentedSize;
+    disabled?: boolean;
+    /** Stretch to fill the container width. */
+    block?: boolean;
+    ariaLabel?: string;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Segmented control: a connected row of single-select segments with the active
+ * one visually raised. Radiogroup semantics with roving tabindex and Arrow /
+ * Home / End keyboard navigation — single-sourced in `createKeyboardNav`.
+ */
+declare function IrisSegmented({ options, value, defaultValue, onValueChange, size, disabled, block, ariaLabel, style, className, }: IrisSegmentedProps): React.ReactElement;
+
+interface IrisImageProps {
+    src: string;
+    alt?: string;
+    width?: number | string;
+    height?: number | string;
+    /** Shown when the image fails to load. */
+    fallback?: string;
+    /** Enable the click-to-zoom preview overlay. Default true. */
+    preview?: boolean;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Image with a graceful error `fallback` and an optional click-to-zoom preview
+ * overlay (a `role="dialog"` lightbox dismissed by backdrop, close button, or
+ * Escape). Lazy-loaded by default.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisImage}.
+ */
+declare function IrisImage({ src, alt, width, height, fallback, preview, style, className, }: IrisImageProps): React.ReactElement;
+
+type IrisFloatButtonShape = 'circle' | 'square';
+interface IrisFloatButtonAction {
+    key: string;
+    icon?: React.ReactNode;
+    label?: string;
+    ariaLabel?: string;
+    onClick?: () => void;
+}
+interface IrisFloatButtonProps {
+    icon?: React.ReactNode;
+    children?: React.ReactNode;
+    ariaLabel?: string;
+    onClick?: () => void;
+    shape?: IrisFloatButtonShape;
+    /** Speed-dial actions; when present, the button toggles them instead of `onClick`. */
+    actions?: IrisFloatButtonAction[];
+    /** Corner offsets (logical: distance from block-end / inline-end). */
+    offset?: {
+        bottom?: number;
+        right?: number;
+    };
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Floating action button: a fixed-position FAB. With `actions` it becomes a
+ * speed-dial — click toggles a `role="menu"` stack of actions (dismissed by
+ * selection, Escape, or outside click). Otherwise click runs `onClick`.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisFloatButton}.
+ */
+declare function IrisFloatButton({ icon, children, ariaLabel, onClick, shape, actions, offset, style, className, }: IrisFloatButtonProps): React.ReactElement;
+
+interface IrisAnchorItem {
+    href: string;
+    title: string;
+    key?: string;
+}
+interface IrisAnchorProps {
+    items: IrisAnchorItem[];
+    /** Scroll container resolver. Defaults to the window. */
+    target?: () => HTMLElement | Window | null;
+    /** Top offset (px) for active detection + scroll target. */
+    offset?: number;
+    onChange?: (href: string) => void;
+    ariaLabel?: string;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Anchor: in-page navigation that scroll-spies its `#id` sections — the active
+ * link is the last section whose top has passed `offset`. Clicking a link
+ * smooth-scrolls to its section (honoring reduced motion).
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisAnchor}.
+ */
+declare function IrisAnchor({ items, target, offset, onChange, ariaLabel, style, className, }: IrisAnchorProps): React.ReactElement;
+
+type IrisCountdownSize = 'sm' | 'md' | 'lg';
+interface IrisCountdownProps {
+    /** Target time as an epoch timestamp (ms). */
+    value: number;
+    /** Token format: DD / HH / mm / ss / SSS. */
+    format?: string;
+    title?: React.ReactNode;
+    prefix?: React.ReactNode;
+    suffix?: React.ReactNode;
+    /** Fired once when the countdown reaches zero. */
+    onFinish?: () => void;
+    size?: IrisCountdownSize;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/** Render remaining milliseconds via DD/HH/mm/ss/SSS tokens. */
+declare function formatRemaining(ms: number, format: string): string;
+/**
+ * Live countdown to a target timestamp. Ticks every second (or every 100ms
+ * when the format shows milliseconds), formats the remaining time via tokens,
+ * and fires `onFinish` once at zero.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisCountdown}.
+ */
+declare function IrisCountdown({ value, format, title, prefix, suffix, onFinish, size, style, className, }: IrisCountdownProps): React.ReactElement;
+
+interface IrisTourStep {
+    /** Element to spotlight for this step. */
+    target?: () => HTMLElement | null;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+}
+interface IrisTourProps {
+    steps: IrisTourStep[];
+    open?: boolean;
+    defaultOpen?: boolean;
+    onChange?: (index: number) => void;
+    onClose?: () => void;
+    onFinish?: () => void;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Guided tour: an overlay that walks the user through `steps`, spotlighting an
+ * optional target per step and showing a dialog card with prev/next/skip
+ * controls. Controlled (`open`) or uncontrolled (`defaultOpen`); the step index
+ * is managed internally and resets each time the tour opens.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisTour}.
+ */
+declare function IrisTour({ steps, open, defaultOpen, onChange, onClose, onFinish, style, className, }: IrisTourProps): React.ReactElement | null;
+
+interface IrisTagInputProps {
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (tags: string[]) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    invalid?: boolean;
+    /** Max number of tags. 0 / undefined = unlimited. */
+    max?: number;
+    allowDuplicates?: boolean;
+    /** id forwarded to the input. Set by `IrisFormField`. */
+    id?: string;
+    ariaDescribedby?: string;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Tag / token input: a field where typed text becomes removable chips. Commit
+ * a tag with Enter or a comma (pasted comma lists split too); Backspace on an
+ * empty input removes the last tag; each chip has a remove button.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisTagInput}.
+ */
+declare function IrisTagInput({ value, defaultValue, onValueChange, placeholder, disabled, invalid, max, allowDuplicates, id, ariaDescribedby, style, className, }: IrisTagInputProps): React.ReactElement;
+
+type IrisCopyButtonSize = 'sm' | 'md' | 'lg';
+interface IrisCopyButtonProps {
+    /** Text to copy to the clipboard. */
+    text: string;
+    /** Idle button content (default: localized "Copy"). */
+    children?: React.ReactNode;
+    /** Content shown briefly after copying (default: localized "Copied"). */
+    copiedLabel?: React.ReactNode;
+    /** How long the copied state lasts (ms). */
+    timeout?: number;
+    onCopy?: (text: string) => void;
+    disabled?: boolean;
+    size?: IrisCopyButtonSize;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Copy-to-clipboard button: writes `text` to the clipboard and flips to a
+ * "Copied" state for `timeout` ms. The clipboard write is best-effort (guarded
+ * for unsupported environments) and the copied state still reflects intent.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisCopyButton}.
+ */
+declare function IrisCopyButton({ text, children, copiedLabel, timeout, onCopy, disabled, size, style, className, }: IrisCopyButtonProps): React.ReactElement;
+
+type IrisProgressCircleStatus = 'default' | 'success' | 'danger' | 'warning';
+interface IrisProgressCircleProps {
+    value: number;
+    max?: number;
+    /** Diameter in px. */
+    size?: number;
+    strokeWidth?: number;
+    status?: IrisProgressCircleStatus;
+    showLabel?: boolean;
+    /** Custom center label given the rounded percent. */
+    format?: (percent: number) => React.ReactNode;
+    ariaLabel?: string;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Circular (ring) progress indicator built from a structured SVG — a track
+ * circle plus a value circle whose `stroke-dashoffset` encodes the ratio. An
+ * optional centered percent label sits on top. Distinct from the linear
+ * `IrisProgress`.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisProgressCircle}.
+ */
+declare function IrisProgressCircle({ value, max, size, strokeWidth, status, showLabel, format, ariaLabel, style, className, }: IrisProgressCircleProps): React.ReactElement;
+
+type IrisSplitButtonVariant = 'primary' | 'default';
+type IrisSplitButtonSize = 'sm' | 'md' | 'lg';
+interface IrisSplitButtonAction {
+    key: string;
+    label: string;
+    disabled?: boolean;
+    onClick?: () => void;
+}
+interface IrisSplitButtonProps {
+    children?: React.ReactNode;
+    onClick?: () => void;
+    actions?: IrisSplitButtonAction[];
+    variant?: IrisSplitButtonVariant;
+    size?: IrisSplitButtonSize;
+    disabled?: boolean;
+    menuAriaLabel?: string;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Split button: a primary action joined to a caret that opens a `role="menu"`
+ * of secondary actions (dismissed by selection, Escape, or outside click).
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisSplitButton}.
+ */
+declare function IrisSplitButton({ children, onClick, actions, variant, size, disabled, menuAriaLabel, style, className, }: IrisSplitButtonProps): React.ReactElement;
+
+interface IrisAspectRatioProps {
+    /** Width / height ratio. Default 16/9. */
+    ratio?: number;
+    children?: React.ReactNode;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Aspect-ratio box: constrains its content to a fixed width/height ratio (via
+ * the CSS `aspect-ratio` property), with an absolutely-filled content layer —
+ * handy for images, video, and iframe embeds.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisAspectRatio}.
+ */
+declare function IrisAspectRatio({ ratio, children, style, className, }: IrisAspectRatioProps): React.ReactElement;
+
+type IrisVisuallyHiddenProps = React.HTMLAttributes<HTMLSpanElement>;
+/**
+ * Visually-hidden content: present in the accessibility tree (read by screen
+ * readers) but clipped from view — for labels, live-region announcements, and
+ * extra context. Forwards attributes like `aria-live` / `role`.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisVisuallyHidden}.
+ */
+declare function IrisVisuallyHidden({ children, style, ...rest }: IrisVisuallyHiddenProps): React.ReactElement;
+
+type IrisScrollAreaAxis = 'vertical' | 'horizontal' | 'both';
+interface IrisScrollAreaProps {
+    maxHeight?: number | string;
+    maxWidth?: number | string;
+    axis?: IrisScrollAreaAxis;
+    children?: React.ReactNode;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Scroll area: a keyboard-focusable scroll container that constrains its
+ * content via `maxHeight` / `maxWidth` and scrolls on the chosen `axis`. A
+ * lightweight alternative to ad-hoc overflow styling.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisScrollArea}.
+ */
+declare function IrisScrollArea({ maxHeight, maxWidth, axis, children, style, className, }: IrisScrollAreaProps): React.ReactElement;
+
+type IrisRibbonPlacement = 'start' | 'end';
+interface IrisRibbonProps {
+    text: React.ReactNode;
+    /** Corner: 'end' = top inline-end (default), 'start' = top inline-start. */
+    placement?: IrisRibbonPlacement;
+    /** Badge background (defaults to the primary color). */
+    color?: string;
+    children?: React.ReactNode;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Ribbon: a corner badge ("New", "Sale", …) anchored to the top corner of its
+ * content. RTL-safe via logical insets/radii.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisRibbon}.
+ */
+declare function IrisRibbon({ text, placement, color, children, style, className, }: IrisRibbonProps): React.ReactElement;
+
+type IrisGaugeStatus = 'default' | 'success' | 'danger' | 'warning';
+interface IrisGaugeProps {
+    value: number;
+    min?: number;
+    max?: number;
+    /** Diameter in px. */
+    size?: number;
+    strokeWidth?: number;
+    status?: IrisGaugeStatus;
+    showValue?: boolean;
+    /** Custom center label given the value and rounded percent. */
+    format?: (value: number, percent: number) => React.ReactNode;
+    ariaLabel?: string;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Semicircular arc gauge built from a structured SVG — a 180° track arc plus a
+ * value arc whose `stroke-dashoffset` encodes `(value − min) / (max − min)`.
+ * Distinct from the full-ring `IrisProgressCircle`.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisGauge}.
+ */
+declare function IrisGauge({ value, min, max, size, strokeWidth, status, showValue, format, ariaLabel, style, className, }: IrisGaugeProps): React.ReactElement;
+
+type IrisMarqueeDirection = 'left' | 'right';
+interface IrisMarqueeProps {
+    children?: React.ReactNode;
+    /** Seconds for one full loop. */
+    duration?: number;
+    direction?: IrisMarqueeDirection;
+    pauseOnHover?: boolean;
+    /** Gap between the repeated copies (px). */
+    gap?: number;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Marquee: an accessible auto-scrolling ticker. The content is rendered twice
+ * (the second copy `aria-hidden`) for a seamless loop and animated with the Web
+ * Animations API (no `@keyframes` injection). Pauses on hover and is disabled
+ * under `prefers-reduced-motion`.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisMarquee}.
+ */
+declare function IrisMarquee({ children, duration, direction, pauseOnHover, gap, style, className, }: IrisMarqueeProps): React.ReactElement;
+
+interface IrisMasonryProps {
+    /** Number of columns. */
+    columns?: number;
+    /** Gap between items (px). */
+    gap?: number;
+    children?: React.ReactNode;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Masonry layout: flows children into balanced columns via CSS multi-column,
+ * with each item kept from breaking across columns — for card grids and
+ * galleries of varying heights.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisMasonry}.
+ */
+declare function IrisMasonry({ columns, gap, children, style, className, }: IrisMasonryProps): React.ReactElement;
+
+interface IrisFieldsetProps {
+    legend?: React.ReactNode;
+    /** Disables the whole group (native fieldset disabling propagates to controls). */
+    disabled?: boolean;
+    hint?: React.ReactNode;
+    children?: React.ReactNode;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Fieldset: a semantic `<fieldset>` / `<legend>` form grouping. `disabled` uses
+ * the native fieldset behavior that cascades to every nested form control —
+ * accessible by construction.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisFieldset}.
+ */
+declare function IrisFieldset({ legend, disabled, hint, children, style, className, }: IrisFieldsetProps): React.ReactElement;
+
+type IrisToolbarOrientation = 'horizontal' | 'vertical';
+interface IrisToolbarProps {
+    children?: React.ReactNode;
+    orientation?: IrisToolbarOrientation;
+    ariaLabel?: string;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Toolbar: a `role="toolbar"` grouping of actions with roving-tabindex keyboard
+ * navigation — one item is in the tab order, and Arrow keys (per orientation)
+ * plus Home/End move focus and the tab stop between the focusable children.
+ *
+ * React port of {@link import('@iris-ui-kit/vue').IrisToolbar}.
+ *
+ * Keyboard navigation is single-sourced in `createKeyboardNav` from the core
+ * package — the controller handles orientation-aware Arrow keys, looping, and
+ * Home/End; this component only owns the bridge to the DOM (tabindex + focus).
+ */
+declare function IrisToolbar({ children, orientation, ariaLabel, style, className, }: IrisToolbarProps): React.ReactElement;
+
+type IrisRadioSize = 'sm' | 'md' | 'lg';
+interface IrisRadioProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'type' | 'size' | 'value' | 'checked' | 'onChange' | 'defaultChecked'> {
+    value: string;
+    size?: IrisRadioSize;
+    children?: React.ReactNode;
+}
+/** Single radio button. Must be used inside an `IrisRadioGroup`. */
+declare const IrisRadio: React.ForwardRefExoticComponent<IrisRadioProps & React.RefAttributes<HTMLInputElement>>;
+
+interface IrisRadioGroupProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange' | 'defaultValue'> {
+    /** Group name. Auto-generated if omitted. */
+    name?: string;
+    value?: string | null;
+    defaultValue?: string | null;
+    onChange?: (next: string) => void;
+    disabled?: boolean;
+    orientation?: 'horizontal' | 'vertical';
+    children?: React.ReactNode;
+}
+/**
+ * React port of {@link import('@iris-ui-kit/vue').IrisRadioGroup}.
+ *
+ * @example
+ *   <IrisRadioGroup value={plan} onChange={setPlan}>
+ *     <IrisRadio value="free">Free</IrisRadio>
+ *     <IrisRadio value="pro">Pro</IrisRadio>
+ *   </IrisRadioGroup>
+ */
+declare function IrisRadioGroup({ name, value, defaultValue, onChange, disabled, orientation, style, children, ...rest }: IrisRadioGroupProps): React.ReactElement;
+
+interface RadioGroupContextValue {
+    name: string;
+    value: string | null;
+    setValue: (next: string) => void;
+    disabled: boolean;
+}
+declare const RadioGroupContext: React.Context<RadioGroupContextValue | null>;
+
+interface IrisSlotProps {
+    children?: React.ReactNode;
+    [key: string]: unknown;
+}
+/**
+ * asChild composition primitive: clones the single React element child and
+ * merges the Slot's own props into it. `style` shallow-merges, `className`
+ * concatenates, event handlers compose (Slot's first, then child's), and any
+ * other prop on the child wins over Slot's. Used as a building block for
+ * trigger primitives that want to render-as the consumer's chosen element.
+ */
+declare const IrisSlot: React.ForwardRefExoticComponent<Omit<IrisSlotProps, "ref"> & React.RefAttributes<unknown>>;
+
+interface IrisFormFieldProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    label?: string;
+    hint?: string;
+    error?: string;
+    required?: boolean;
+    /** Override the auto-generated control id. */
+    labelFor?: string;
+    /** Visual size of the label. */
+    size?: 'sm' | 'md';
+    children?: React.ReactNode;
+}
+/**
+ * Form-field wrapper that handles the label / hint / error trio with the
+ * right a11y plumbing. Non-invasive wrapper around any Iris input primitive
+ * (`IrisInput`, `IrisTextarea`, `IrisNumberInput`, `IrisSwitch`, `IrisCheckbox`,
+ * `IrisPasswordInput`, …): locates the first valid React element in `children`
+ * and clones it with the generated `id`, `aria-describedby`, and `invalid`.
+ *
+ * ```tsx
+ * <IrisFormField label="Email" error={errors.email} hint="We never share it.">
+ *   <IrisInput value={email} onChange={setEmail} />
+ * </IrisFormField>
+ * ```
+ */
+declare const IrisFormField: React.ForwardRefExoticComponent<IrisFormFieldProps & React.RefAttributes<HTMLDivElement>>;
+
+interface IrisTooltipProps {
+    /** Plain-text tooltip content. */
+    content?: React.ReactNode;
+    /** Side relative to the trigger; may flip to stay in view. */
+    placement?: Placement;
+    /** Pixel offset between trigger and tooltip. */
+    offset?: number;
+    /** Hover/focus dwell before opening, in ms. */
+    openDelay?: number;
+    /** Hover/blur dwell before closing, in ms. */
+    closeDelay?: number;
+    /** Portal target. `false` renders in place; an HTMLElement renders inside it; default = `document.body`. */
+    portalTarget?: HTMLElement | false;
+    /** Disable the tooltip without removing the trigger. */
+    disabled?: boolean;
+    children?: React.ReactNode;
+}
+/**
+ * Hover / focus triggered tooltip. Powered by `createHoverIntent` state machine.
+ *
+ * Zero-delay uses `hi.open()`/`hi.close()` (FORCE_OPEN/FORCE_CLOSE — single
+ * machine transition) so React renders synchronously. Positive delays use
+ * `hi.pointerEnter()`/`hi.pointerLeave()` with the machine's `after` timer.
+ *
+ * @example
+ *   <IrisTooltip content="Save changes">
+ *     <button>Save</button>
+ *   </IrisTooltip>
+ */
+declare function IrisTooltip({ content, placement, offset, openDelay, closeDelay, portalTarget, disabled, children, }: IrisTooltipProps): React.ReactElement | null;
+
+interface IrisPopoverProps {
+    /** Controlled open value. Combine with `onOpenChange`. */
+    open?: boolean;
+    /** Initial open value in uncontrolled mode. */
+    defaultOpen?: boolean;
+    /** Called whenever the open state changes (controlled or uncontrolled). */
+    onOpenChange?: (open: boolean) => void;
+    /** Anchor placement; may be flipped by Floating UI to stay in view. */
+    placement?: Placement;
+    /** Distance in px between trigger and content. */
+    offset?: number;
+    children?: React.ReactNode;
+}
+/**
+ * Root provider for a Popover surface. Wraps the trigger and the content,
+ * threads a state machine + DOM refs + positioning options through context.
+ * Supports controlled (`open` + `onOpenChange`) and uncontrolled (`defaultOpen`)
+ * modes.
+ *
+ * @example
+ *   <IrisPopover defaultOpen={false} placement="bottom-start">
+ *     <IrisPopoverTrigger>Click me</IrisPopoverTrigger>
+ *     <IrisPopoverContent>Hello</IrisPopoverContent>
+ *   </IrisPopover>
+ */
+declare function IrisPopover({ open: openProp, defaultOpen, onOpenChange, placement, offset, children, }: IrisPopoverProps): React.ReactElement;
+
+interface IrisPopoverTriggerProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'children'> {
+    /** Use the single child as the trigger instead of rendering a `<button>`. */
+    asChild?: boolean;
+    children?: React.ReactNode;
+}
+/**
+ * The element the user interacts with to toggle the Popover. Renders a
+ * `<button type="button">` by default; pass `asChild` to attach behavior to
+ * any single element (e.g. `<IrisButton>` or `<a>`).
+ *
+ * a11y attributes wired automatically:
+ *   - `aria-haspopup="dialog"`
+ *   - `aria-expanded="true|false"` driven by the open state
+ *   - `aria-controls` pointing at the content's id
+ */
+declare const IrisPopoverTrigger: React.ForwardRefExoticComponent<IrisPopoverTriggerProps & React.RefAttributes<HTMLElement>>;
+
+interface IrisPopoverContentProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    /** Portal target. `false` renders in place; an HTMLElement renders inside it; default = `document.body`. */
+    portalTarget?: HTMLElement | false;
+    /** Move focus into the content on open (default: true). */
+    autoFocus?: boolean;
+    /** Restore focus to the trigger on close (default: true). */
+    restoreFocus?: boolean;
+    children?: React.ReactNode;
+}
+/**
+ * The floating panel rendered when the Popover is open. Position is computed
+ * by `useFloating` (Floating UI); dismissal is handled by document-level
+ * pointerdown + Escape listeners. Focus moves into the content on open and
+ * back to the trigger on close.
+ *
+ * The content is portaled to `document.body` by default to avoid stacking /
+ * overflow / z-index foot-guns. Pass `portalTarget={false}` to render inline.
+ */
+declare const IrisPopoverContent: React.ForwardRefExoticComponent<IrisPopoverContentProps & React.RefAttributes<HTMLDivElement>>;
+
+interface PopoverContextValue {
+    open: boolean;
+    setOpen: (next: boolean) => void;
+    triggerRef: React.MutableRefObject<HTMLElement | null>;
+    contentRef: React.MutableRefObject<HTMLElement | null>;
+    contentId: string;
+    placement: Placement;
+    offset: number;
+}
+declare const PopoverContext: React.Context<PopoverContextValue | null>;
+declare function usePopoverContext(componentName: string): PopoverContextValue;
+
+interface IrisDialogProps {
+    /** Controlled open value. Combine with `onOpenChange`. */
+    open?: boolean;
+    /** Initial open value in uncontrolled mode. */
+    defaultOpen?: boolean;
+    /** Emitted whenever the open state changes. */
+    onOpenChange?: (open: boolean) => void;
+    /** Close on backdrop click. Default `true`. */
+    closeOnOutsideClick?: boolean;
+    /** Close on Escape key. Default `true`. */
+    closeOnEscape?: boolean;
+    children?: React.ReactNode;
+}
+/**
+ * Modal dialog root. Wraps a Trigger + Content (+ optional Title /
+ * Description / Close) and threads a state machine + DOM refs + IDs through
+ * React context. Supports controlled (`open` + `onOpenChange`) and
+ * uncontrolled (`defaultOpen`) modes.
+ *
+ * Unlike `IrisPopover`, Dialog:
+ *   - centers content with no anchor positioning,
+ *   - locks body scroll while open,
+ *   - traps Tab focus inside the content,
+ *   - renders a backdrop overlay that dismisses on click.
+ *
+ * @example
+ *   <IrisDialog>
+ *     <IrisDialogTrigger>Open</IrisDialogTrigger>
+ *     <IrisDialogContent>
+ *       <IrisDialogTitle>Confirm</IrisDialogTitle>
+ *       <IrisDialogClose>Done</IrisDialogClose>
+ *     </IrisDialogContent>
+ *   </IrisDialog>
+ */
+declare function IrisDialog({ open: openProp, defaultOpen, onOpenChange, closeOnOutsideClick, closeOnEscape, children, }: IrisDialogProps): React.ReactElement;
+
+interface IrisDialogTriggerProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'children'> {
+    /** Use the single child as the trigger instead of rendering a `<button>`. */
+    asChild?: boolean;
+    children?: React.ReactNode;
+}
+/**
+ * The element the user clicks to open the dialog. Renders a
+ * `<button type="button">` by default; pass `asChild` to attach behavior
+ * to any single element.
+ */
+declare const IrisDialogTrigger: React.ForwardRefExoticComponent<IrisDialogTriggerProps & React.RefAttributes<HTMLElement>>;
+
+interface IrisDialogContentProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    /** Portal target. `false` renders in place; default = `document.body`. */
+    portalTarget?: HTMLElement | false;
+    children?: React.ReactNode;
+}
+/**
+ * The modal surface (and its backdrop). Renders only while the dialog is
+ * open. Behaviors enabled automatically:
+ *
+ *   - **Body scroll lock** — reference-counted across stacked dialogs.
+ *   - **Focus trap** — Tab cycling within content; restores focus on close.
+ *   - **Escape to dismiss** — controlled by `Dialog.closeOnEscape`.
+ *   - **Backdrop click to dismiss** — controlled by `Dialog.closeOnOutsideClick`.
+ *   - **ARIA** — `role="dialog"`, `aria-modal="true"`, `aria-labelledby` /
+ *     `aria-describedby` wired automatically when `<IrisDialogTitle>` /
+ *     `<IrisDialogDescription>` are present.
+ */
+declare const IrisDialogContent: React.ForwardRefExoticComponent<IrisDialogContentProps & React.RefAttributes<HTMLDivElement>>;
+interface IrisDialogTitleProps extends React.HTMLAttributes<HTMLHeadingElement> {
+    as?: keyof React.JSX.IntrinsicElements;
+}
+/**
+ * Sets `aria-labelledby` on the dialog content automatically. Renders an
+ * `<h2>` by default.
+ */
+declare const IrisDialogTitle: React.ForwardRefExoticComponent<IrisDialogTitleProps & React.RefAttributes<HTMLElement>>;
+interface IrisDialogDescriptionProps extends React.HTMLAttributes<HTMLParagraphElement> {
+    as?: keyof React.JSX.IntrinsicElements;
+}
+/**
+ * Sets `aria-describedby` on the dialog content automatically. Renders a
+ * `<p>` by default.
+ */
+declare const IrisDialogDescription: React.ForwardRefExoticComponent<IrisDialogDescriptionProps & React.RefAttributes<HTMLElement>>;
+interface IrisDialogCloseProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'children'> {
+    asChild?: boolean;
+    children?: React.ReactNode;
+}
+/** Close button. Renders a `<button type="button">` or, with `asChild`, wraps the provided child. */
+declare const IrisDialogClose: React.ForwardRefExoticComponent<IrisDialogCloseProps & React.RefAttributes<HTMLElement>>;
+
+interface DialogContextValue {
+    open: boolean;
+    setOpen: (next: boolean) => void;
+    triggerRef: React.MutableRefObject<HTMLElement | null>;
+    contentRef: React.MutableRefObject<HTMLElement | null>;
+    contentId: string;
+    titleId: string;
+    descriptionId: string;
+    hasTitle: boolean;
+    hasDescription: boolean;
+    registerTitle: () => () => void;
+    registerDescription: () => () => void;
+    closeOnOutsideClick: boolean;
+    closeOnEscape: boolean;
+}
+declare const DialogContext: React.Context<DialogContextValue | null>;
+declare function useDialogContext(componentName: string): DialogContextValue;
+
+type IrisDrawerSide = 'left' | 'right' | 'top' | 'bottom';
+interface DrawerContextValue {
+    open: boolean;
+    setOpen: (next: boolean) => void;
+    triggerRef: React.MutableRefObject<HTMLElement | null>;
+    contentRef: React.MutableRefObject<HTMLElement | null>;
+    contentId: string;
+    titleId: string;
+    side: IrisDrawerSide;
+    size: string;
+    hasTitle: boolean;
+    registerTitle: () => () => void;
+    closeOnOutsideClick: boolean;
+    closeOnEscape: boolean;
+}
+declare const DrawerContext: React.Context<DrawerContextValue | null>;
+declare function useDrawerContext(componentName: string): DrawerContextValue;
+
+interface IrisDrawerProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    side?: IrisDrawerSide;
+    /** Width (for left/right) or height (for top/bottom). Any CSS length. */
+    size?: string;
+    closeOnOutsideClick?: boolean;
+    closeOnEscape?: boolean;
+    children?: React.ReactNode;
+}
+/**
+ * Slide-in overlay. Mirrors `IrisDialog`'s composition but anchors to a
+ * screen edge with a transform-based open animation. Defaults to the right.
+ *
+ * @example
+ *   <IrisDrawer>
+ *     <IrisDrawerTrigger>Open</IrisDrawerTrigger>
+ *     <IrisDrawerContent>
+ *       <IrisDrawerTitle>Settings</IrisDrawerTitle>
+ *       <p>…</p>
+ *       <IrisDrawerClose>Close</IrisDrawerClose>
+ *     </IrisDrawerContent>
+ *   </IrisDrawer>
+ */
+declare function IrisDrawer({ open: openProp, defaultOpen, onOpenChange, side, size, closeOnOutsideClick, closeOnEscape, children, }: IrisDrawerProps): React.ReactElement;
+
+interface IrisDrawerTriggerProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'children'> {
+    asChild?: boolean;
+    children?: React.ReactNode;
+}
+/**
+ * The trigger that opens the drawer when clicked. Renders as a `<button>` (or
+ * as custom children when `asChild`). Injects `aria-haspopup="dialog"` and
+ * `aria-expanded` for screen-reader awareness.
+ */
+declare const IrisDrawerTrigger: React.ForwardRefExoticComponent<IrisDrawerTriggerProps & React.RefAttributes<HTMLElement>>;
+
+interface IrisDrawerContentProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    portalTarget?: HTMLElement | false;
+    children?: React.ReactNode;
+}
+/**
+ * The slide-in surface. Mounts when `open` becomes true and unmounts
+ * `EXIT_DURATION_MS` after `open` becomes false so the slide-out transition
+ * runs before removal. Provides backdrop, body scroll lock, focus trap, and
+ * Escape / outside-click dismiss.
+ */
+declare const IrisDrawerContent: React.ForwardRefExoticComponent<IrisDrawerContentProps & React.RefAttributes<HTMLDivElement>>;
+type IrisDrawerTitleProps = React.HTMLAttributes<HTMLHeadingElement>;
+/**
+ * The drawer's header title, rendered as an `<h2>`. Automatically wired to
+ * `aria-labelledby` on the content panel for accessible naming.
+ */
+declare const IrisDrawerTitle: React.ForwardRefExoticComponent<IrisDrawerTitleProps & React.RefAttributes<HTMLHeadingElement>>;
+interface IrisDrawerCloseProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'children'> {
+    asChild?: boolean;
+    children?: React.ReactNode;
+}
+/**
+ * A button that closes the drawer when clicked. Supports `asChild` for custom
+ * trigger elements. Emits `onClick` then calls `setOpen(false)`.
+ */
+declare const IrisDrawerClose: React.ForwardRefExoticComponent<IrisDrawerCloseProps & React.RefAttributes<HTMLElement>>;
+
+interface IrisDropdownProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    placement?: Placement;
+    offset?: number;
+    children?: React.ReactNode;
+}
+/**
+ * Dropdown menu root. Composes `createFloatingMachine` (state) with
+ * `useFloating` (positioning) used in `IrisDropdownMenu`. The dropdown
+ * panel's semantics differ from a popover: it uses `role="menu"`, supports
+ * arrow-key navigation, and items auto-close the menu on select.
+ *
+ * @example
+ *   <IrisDropdown placement="bottom-end">
+ *     <IrisDropdownTrigger>Actions</IrisDropdownTrigger>
+ *     <IrisDropdownMenu>
+ *       <IrisDropdownItem onSelect={onCopy}>Copy</IrisDropdownItem>
+ *       <IrisDropdownItem onSelect={onDelete}>Delete</IrisDropdownItem>
+ *     </IrisDropdownMenu>
+ *   </IrisDropdown>
+ */
+declare function IrisDropdown({ open: openProp, defaultOpen, onOpenChange, placement, offset, children, }: IrisDropdownProps): React.ReactElement;
+
+interface IrisDropdownTriggerProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'children'> {
+    asChild?: boolean;
+    children?: React.ReactNode;
+}
+/**
+ * The trigger element that toggles the dropdown open/closed on click or
+ * ArrowDown/Enter/Space. Renders as a `<button>` (or custom element via
+ * `asChild`) with `aria-haspopup="menu"` and `aria-expanded`.
+ */
+declare const IrisDropdownTrigger: React.ForwardRefExoticComponent<IrisDropdownTriggerProps & React.RefAttributes<HTMLElement>>;
+
+interface IrisDropdownMenuProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    portalTarget?: HTMLElement | false;
+    children?: React.ReactNode;
+}
+/**
+ * The menu surface. Renders `role="menu"` and handles ArrowUp/Down/Home/End
+ * navigation across child `IrisDropdownItem`s. Closes on Escape, outside
+ * pointerdown, and Tab.
+ */
+declare const IrisDropdownMenu: React.ForwardRefExoticComponent<IrisDropdownMenuProps & React.RefAttributes<HTMLDivElement>>;
+
+interface IrisDropdownItemProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onSelect'> {
+    disabled?: boolean;
+    /** When true, selecting does NOT close the dropdown. */
+    keepOpen?: boolean;
+    /** Emitted on click or Enter/Space. */
+    onSelect?: (event: React.SyntheticEvent) => void;
+}
+/**
+ * A single selectable menu item. Calls `onSelect` and auto-closes the
+ * parent dropdown after selection (unless `keepOpen`). Disabled items are
+ * skipped by arrow-key navigation in the parent menu.
+ */
+declare const IrisDropdownItem: React.ForwardRefExoticComponent<IrisDropdownItemProps & React.RefAttributes<HTMLDivElement>>;
+type IrisDropdownSeparatorProps = React.HTMLAttributes<HTMLDivElement>;
+/**
+ * A visual separator (horizontal rule) within a dropdown menu. Renders a
+ * `role="separator"` `<div>` styled with the theme's border colour.
+ */
+declare const IrisDropdownSeparator: React.ForwardRefExoticComponent<IrisDropdownSeparatorProps & React.RefAttributes<HTMLDivElement>>;
+
+interface DropdownContextValue {
+    open: boolean;
+    setOpen: (next: boolean) => void;
+    triggerRef: React.MutableRefObject<HTMLElement | null>;
+    contentRef: React.MutableRefObject<HTMLElement | null>;
+    contentId: string;
+    placement: Placement;
+    offset: number;
+}
+declare const DropdownContext: React.Context<DropdownContextValue | null>;
+declare function useDropdownContext(componentName: string): DropdownContextValue;
+
+type IrisToastVariant = 'default' | 'success' | 'danger' | 'warning' | 'info';
+interface IrisToastInput {
+    /** Stable id; if reused, the existing toast is updated in place. */
+    id?: string;
+    title?: string;
+    description?: string;
+    variant?: IrisToastVariant;
+    /** Auto-dismiss duration in ms. `0` or `Infinity` disables auto-dismiss. */
+    duration?: number;
+    /** Optional action label + handler. */
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+}
+interface IrisToast extends Required<Omit<IrisToastInput, 'action'>> {
+    action: IrisToastInput['action'];
+    createdAt: number;
+}
+/** Subscribe to changes. */
+declare const subscribeToasts: (listener: (toasts: IrisToast[]) => void) => () => void;
+/** Read current toasts. */
+declare const getToasts: () => IrisToast[];
+/**
+ * Push a toast onto the queue. If an `id` is supplied and matches an existing
+ * toast, the entry is replaced in place (and its timer reset).
+ *
+ * Returns the toast id so the caller can `dismissToast(id)` later.
+ */
+declare function pushToast(input: IrisToastInput): string;
+/** Remove a toast by id. */
+declare function dismissToast(id: string): void;
+/** Remove all toasts. */
+declare function clearToasts(): void;
+
+interface UseToastReturn {
+    /** Push a new toast (or replace by id). Returns the toast id. */
+    push: (input: IrisToastInput) => string;
+    /** Convenience: push with variant pre-set. */
+    success: (input: Omit<IrisToastInput, 'variant'>) => string;
+    error: (input: Omit<IrisToastInput, 'variant'>) => string;
+    warning: (input: Omit<IrisToastInput, 'variant'>) => string;
+    info: (input: Omit<IrisToastInput, 'variant'>) => string;
+    /** Remove a toast by id. */
+    dismiss: (id: string) => void;
+    /** Remove all toasts. */
+    clear: () => void;
+}
+/**
+ * Hook for the global toast queue. Backed by a module-level singleton
+ * store, so it works **without** a surrounding provider — but the page
+ * must mount exactly one `<IrisToastViewport>` somewhere for toasts to
+ * actually be visible.
+ *
+ * @example
+ *   const toast = useToast()
+ *   toast.success({ title: 'Saved', description: 'Your changes are live.' })
+ *   toast.error({ title: 'Failed', duration: 6000 })
+ */
+declare function useToast(): UseToastReturn;
+
+type IrisToastPosition = 'top-left' | 'top-right' | 'top-center' | 'bottom-left' | 'bottom-right' | 'bottom-center';
+interface IrisToastViewportProps extends React.HTMLAttributes<HTMLDivElement> {
+    position?: IrisToastPosition;
+    portalTarget?: HTMLElement | false;
+    /** Maximum simultaneous toasts; older entries are evicted when exceeded. */
+    max?: number;
+}
+/**
+ * Renders the queued toasts. Mount exactly **one** of these per page. The
+ * viewport subscribes to the module-level toast store; toasts pushed via
+ * `useToast()` from any component appear here.
+ *
+ * Auto-dismiss timers are managed per toast (paused while the pointer is over
+ * the viewport). Manual dismiss is via the close button.
+ */
+declare function IrisToastViewport({ position, portalTarget, max, style, ...rest }: IrisToastViewportProps): React.ReactElement | null;
+
+type IrisTabsOrientation = 'horizontal' | 'vertical';
+interface TabsContextValue {
+    value: string | null;
+    setValue: (next: string) => void;
+    orientation: IrisTabsOrientation;
+    disabled: boolean;
+    lazy: boolean;
+    /** Registers a trigger (mount). Returns an unregister function. */
+    registerTrigger: (value: string, isDisabled: () => boolean) => () => void;
+    moveFocus: (from: string, delta: 1 | -1 | 'home' | 'end') => void;
+    listRef: React.MutableRefObject<HTMLElement | null>;
+}
+declare const TabsContext: React.Context<TabsContextValue | null>;
+declare function useTabsContext(componentName: string): TabsContextValue;
+
+interface IrisTabsProps {
+    /** Controlled active value. */
+    value?: string;
+    /** Initial active value in uncontrolled mode. */
+    defaultValue?: string;
+    onValueChange?: (next: string) => void;
+    orientation?: IrisTabsOrientation;
+    disabled?: boolean;
+    /** When true (default), content panels are unmounted when not active. */
+    lazy?: boolean;
+    children?: React.ReactNode;
+}
+/**
+ * Tabs root. Provides context for value, orientation, lazy mounting, and the
+ * ordered set of registered triggers so arrow-key navigation can move focus
+ * deterministically (skipping disabled triggers).
+ *
+ * @example
+ *   <IrisTabs defaultValue="a">
+ *     <IrisTabsList>
+ *       <IrisTabsTrigger value="a">First</IrisTabsTrigger>
+ *       <IrisTabsTrigger value="b">Second</IrisTabsTrigger>
+ *     </IrisTabsList>
+ *     <IrisTabsContent value="a">Panel A</IrisTabsContent>
+ *     <IrisTabsContent value="b">Panel B</IrisTabsContent>
+ *   </IrisTabs>
+ */
+declare function IrisTabs({ value: valueProp, defaultValue, onValueChange, orientation, disabled, lazy, children, }: IrisTabsProps): React.ReactElement;
+
+type IrisTabsListProps = React.HTMLAttributes<HTMLDivElement>;
+/** Container for `IrisTabsTrigger`s. Renders `<div role="tablist">`. */
+declare const IrisTabsList: React.ForwardRefExoticComponent<IrisTabsListProps & React.RefAttributes<HTMLDivElement>>;
+
+interface IrisTabsTriggerProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'value' | 'children'> {
+    value: string;
+    asChild?: boolean;
+    children?: React.ReactNode;
+}
+/**
+ * A single tab button. Registers with the parent `IrisTabs` so arrow keys
+ * can navigate among triggers in registration order. Sets `aria-selected`
+ * and `aria-controls`; uses roving tabindex.
+ */
+declare const IrisTabsTrigger: React.ForwardRefExoticComponent<IrisTabsTriggerProps & React.RefAttributes<HTMLElement>>;
+
+interface IrisTabsContentProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    value: string;
+    /** Render even when inactive; hidden via the `hidden` attribute. */
+    forceMount?: boolean;
+    children?: React.ReactNode;
+}
+/**
+ * Panel paired with a `IrisTabsTrigger` by matching `value`. When `lazy` is
+ * true on the parent (default), inactive panels are unmounted. Pass
+ * `forceMount` to always render (e.g. for SEO or pre-warming).
+ */
+declare const IrisTabsContent: React.ForwardRefExoticComponent<IrisTabsContentProps & React.RefAttributes<HTMLDivElement>>;
+
+type IrisAccordionValue = string | string[] | null;
+interface IrisAccordionProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange' | 'defaultValue'> {
+    value?: IrisAccordionValue;
+    defaultValue?: IrisAccordionValue;
+    onValueChange?: (next: IrisAccordionValue) => void;
+    multiple?: boolean;
+    /** In single mode, allow zero items open. */
+    collapsible?: boolean;
+}
+/**
+ * Container for collapsible sections.
+ *
+ *   - `multiple=false` (default): zero or one item open at a time. The value
+ *     is `string | null`. Set `collapsible` to allow closing the active one.
+ *   - `multiple=true`: any number of items open. Value is `string[]`.
+ */
+declare function IrisAccordion({ value: valueProp, defaultValue, onValueChange, multiple, collapsible, children, ...rest }: IrisAccordionProps): React.ReactElement;
+
+interface IrisAccordionItemProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title'> {
+    value: string;
+    title?: React.ReactNode;
+    disabled?: boolean;
+}
+/**
+ * A single accordion section: a button-styled header + a collapsible body.
+ * Wires `aria-expanded`, `aria-controls`, `role="region"`, `aria-labelledby`.
+ */
+declare const IrisAccordionItem: React.ForwardRefExoticComponent<IrisAccordionItemProps & React.RefAttributes<HTMLDivElement>>;
+
+interface AccordionContextValue {
+    isOpen: (value: string) => boolean;
+    toggle: (value: string) => void;
+    rootId: string;
+    collapsible: boolean;
+    multiple: boolean;
+    /** Current keyboard‑navigation active index. */
+    activeIndex: number;
+    /**
+     * Register a trigger element for keyboard navigation.
+     * Returns an unregister function for cleanup.
+     */
+    registerItem: (value: string, el: React.RefObject<HTMLButtonElement | null>) => () => void;
+    /** Tell the nav controller to focus the item with the given value. */
+    focusItem: (value: string) => void;
+}
+declare const AccordionContext: React.Context<AccordionContextValue | null>;
+declare function useAccordionContext(componentName: string): AccordionContextValue;
+
+type IrisStepperOrientation = 'horizontal' | 'vertical';
+type IrisStepStatus = 'pending' | 'active' | 'completed' | 'error';
+interface StepperContextValue {
+    current: number;
+    total: number;
+    orientation: IrisStepperOrientation;
+    linear: boolean;
+    /** Register a step at mount. Returns the assigned index and an unregister fn. */
+    registerStep: () => {
+        index: number;
+        unregister: () => void;
+    };
+    goTo: (index: number) => void;
+    computeStatus: (index: number) => IrisStepStatus;
+}
+declare const StepperContext: React.Context<StepperContextValue | null>;
+declare function useStepperContext(componentName: string): StepperContextValue;
+
+interface IrisStepperProps extends Omit<React.HTMLAttributes<HTMLOListElement>, 'onChange'> {
+    value?: number;
+    defaultValue?: number;
+    onValueChange?: (next: number) => void;
+    orientation?: IrisStepperOrientation;
+    /** When true (default), forward navigation is blocked beyond the current step. */
+    linear?: boolean;
+}
+/**
+ * Multi-step flow container. Children should be `IrisStepperStep`s; each
+ * registers itself with the stepper's context and self-renders its indicator
+ * + title.
+ */
+declare function IrisStepper({ value: valueProp, defaultValue, onValueChange, orientation, linear, style, children, ...rest }: IrisStepperProps): React.ReactElement;
+
+interface IrisStepperStepProps extends Omit<React.HTMLAttributes<HTMLLIElement>, 'title'> {
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    /** Force a status; otherwise computed from position vs current. */
+    status?: IrisStepStatus;
+    disabled?: boolean;
+}
+/**
+ * A single step in an {@link IrisStepper}. Auto-numbers based on its position
+ * in the document order (registers on mount). Click forwards through `goTo`
+ * which gates by `linear`.
+ */
+declare const IrisStepperStep: React.ForwardRefExoticComponent<IrisStepperStepProps & React.RefAttributes<HTMLLIElement>>;
+
+type IrisToggleGroupType = 'single' | 'multiple';
+type IrisToggleGroupOrientation = 'horizontal' | 'vertical';
+type IrisToggleGroupVariant = 'outline' | 'solid';
+type IrisToggleGroupSize = 'sm' | 'md' | 'lg';
+interface ToggleGroupContextValue {
+    type: IrisToggleGroupType;
+    orientation: IrisToggleGroupOrientation;
+    size: IrisToggleGroupSize;
+    variant: IrisToggleGroupVariant;
+    disabled: boolean;
+    isActive: (value: string) => boolean;
+    toggle: (value: string) => void;
+    registerItem: (value: string, el: {
+        current: HTMLElement | null;
+    }) => () => void;
+    moveFocus: (from: string, delta: 1 | -1 | 'home' | 'end') => void;
+    focusItem: (value: string) => void;
+}
+declare const ToggleGroupContext: React.Context<ToggleGroupContextValue | null>;
+declare function useToggleGroupContext(componentName: string): ToggleGroupContextValue;
+
+type IrisToggleGroupValue = string | string[] | null;
+interface IrisToggleGroupSingleProps {
+    type?: 'single';
+    value?: string | null;
+    defaultValue?: string | null;
+    onValueChange?: (next: string | null) => void;
+}
+interface IrisToggleGroupMultipleProps {
+    type: 'multiple';
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (next: string[]) => void;
+}
+type IrisToggleGroupProps = (IrisToggleGroupSingleProps | IrisToggleGroupMultipleProps) & Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange' | 'defaultValue' | 'type'> & {
+    orientation?: IrisToggleGroupOrientation;
+    size?: IrisToggleGroupSize;
+    variant?: IrisToggleGroupVariant;
+    disabled?: boolean;
+};
+/**
+ * Segmented control. Two modes:
+ *   - `type="single"` — radio-like; value is `string | null`. Root gets
+ *     `role="radiogroup"`, items get `role="radio"` + `aria-checked`.
+ *   - `type="multiple"` — toggle-like; value is `string[]`. Root gets
+ *     `role="group"`, items get `aria-pressed`.
+ */
+declare function IrisToggleGroup(props: IrisToggleGroupProps): React.ReactElement;
+
+interface IrisToggleGroupItemProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'value' | 'type'> {
+    value: string;
+}
+/**
+ * One toggle in an `IrisToggleGroup`. Renders a `<button>` with the correct
+ * `role` / `aria-checked` / `aria-pressed` for the group's type.
+ */
+declare const IrisToggleGroupItem: React.ForwardRefExoticComponent<IrisToggleGroupItemProps & React.RefAttributes<HTMLButtonElement>>;
+
+type IrisPaginationSize = 'sm' | 'md';
+interface IrisPaginationProps extends Omit<React.HTMLAttributes<HTMLElement>, 'onChange'> {
+    /** Current page (1-indexed). Controlled. */
+    value?: number;
+    /** Initial page in uncontrolled mode. */
+    defaultValue?: number;
+    onValueChange?: (next: number) => void;
+    /** Total number of items across all pages. */
+    total: number;
+    pageSize?: number;
+    siblingCount?: number;
+    showFirstLast?: boolean;
+    size?: IrisPaginationSize;
+    disabled?: boolean;
+}
+/**
+ * Numeric page selector with prev/next + optional first/last buttons and
+ * two-sided ellipsis. Stateless visual; the caller owns `value`.
+ *
+ * @example
+ *   <IrisPagination total={240} pageSize={20} value={page} onValueChange={setPage} />
+ */
+declare function IrisPagination({ value: valueProp, defaultValue, onValueChange, total, pageSize, siblingCount, showFirstLast, size, disabled, style, ...rest }: IrisPaginationProps): React.ReactElement;
+
+interface IrisBreadcrumbProps extends React.HTMLAttributes<HTMLElement> {
+    /** String separator between crumbs. Default `/`. */
+    separator?: React.ReactNode;
+    children?: React.ReactNode;
+}
+/**
+ * Container for breadcrumb navigation. Renders a `<nav>` with an `<ol>` per
+ * WAI-ARIA. Inserts `separator` between items and tags the last child with
+ * `isCurrent` so it renders as plain text + `aria-current="page"`.
+ */
+declare const IrisBreadcrumb: React.ForwardRefExoticComponent<IrisBreadcrumbProps & React.RefAttributes<HTMLElement>>;
+
+interface IrisBreadcrumbItemProps extends React.HTMLAttributes<HTMLElement> {
+    href?: string;
+    /** Internal: set by parent `IrisBreadcrumb` when this is the last item. */
+    isCurrent?: boolean;
+    children?: React.ReactNode;
+}
+/**
+ * A single breadcrumb crumb. Renders an `<a>` when `href` is given and the
+ * crumb is not the last one; otherwise a `<span>`. The `isCurrent` flag is
+ * set automatically by the parent `IrisBreadcrumb` based on position.
+ */
+declare const IrisBreadcrumbItem: React.ForwardRefExoticComponent<IrisBreadcrumbItemProps & React.RefAttributes<HTMLElement>>;
+
+interface IrisDraggerPosition {
+    x: number;
+    y: number;
+}
+interface IrisDraggerBounds {
+    minX?: number;
+    maxX?: number;
+    minY?: number;
+    maxY?: number;
+}
+interface IrisDraggerProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange' | 'defaultValue' | 'onDragStart' | 'onDragEnd'> {
+    value?: IrisDraggerPosition;
+    defaultValue?: IrisDraggerPosition;
+    onValueChange?: (next: IrisDraggerPosition) => void;
+    onDragStart?: (start: IrisDraggerPosition) => void;
+    onDragEnd?: (end: IrisDraggerPosition) => void;
+    disabled?: boolean;
+    /** Constrain the position to within these bounds (px from wrapper origin). */
+    bounds?: IrisDraggerBounds;
+    /** Optional drag handle (restricts the draggable region). */
+    handle?: React.ReactNode;
+}
+/**
+ * Make a child element positionable by drag. The wrapper is absolutely
+ * positioned at its parent's top-left; the position is driven by `value` /
+ * `defaultValue` (px). Drag uses pointer capture so the gesture survives
+ * the pointer leaving the element.
+ */
+declare function IrisDragger({ value: valueProp, defaultValue, onValueChange, onDragStart, onDragEnd, disabled, bounds, handle, style, children, ...rest }: IrisDraggerProps): React.ReactElement;
+
+type IrisSplitterOrientation = 'horizontal' | 'vertical';
+interface IrisSplitterProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    orientation?: IrisSplitterOrientation;
+    /** Split ratio in [0, 1]. */
+    value?: number;
+    defaultValue?: number;
+    onValueChange?: (next: number) => void;
+    /** Minimum size of the start pane in px. */
+    minStart?: number;
+    /** Minimum size of the end pane in px. */
+    minEnd?: number;
+    disabled?: boolean;
+    /** Start pane content. */
+    start?: React.ReactNode;
+    /** End pane content. */
+    end?: React.ReactNode;
+}
+/**
+ * Two-pane splitter with a draggable divider. The split position is a number
+ * in `[0, 1]`. Clamping respects `minStart` / `minEnd` (in px) so panes
+ * cannot collapse below a usable size.
+ */
+declare function IrisSplitter({ orientation, value: valueProp, defaultValue, onValueChange, minStart, minEnd, disabled, style, start, end, ...rest }: IrisSplitterProps): React.ReactElement;
+
+type IrisResizerHandle = 'top' | 'right' | 'bottom' | 'left' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+interface IrisResizerSize {
+    width: number;
+    height: number;
+}
+interface IrisResizerProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    value: IrisResizerSize;
+    onValueChange: (next: IrisResizerSize) => void;
+    onResizeStart?: (start: IrisResizerSize) => void;
+    onResizeEnd?: (end: IrisResizerSize) => void;
+    handles?: IrisResizerHandle[];
+    minWidth?: number;
+    minHeight?: number;
+    maxWidth?: number;
+    maxHeight?: number;
+    disabled?: boolean;
+    /** Maintain `width / height` ratio when dragging corner handles. */
+    keepAspect?: boolean;
+}
+/**
+ * 8-direction resizer wrapping a single child element. The child is rendered
+ * inside a relatively positioned wrapper; handles overlay each side and
+ * corner. Drag updates `value` ({ width, height } in px) clamped by min/max.
+ */
+declare function IrisResizer({ value, onValueChange, onResizeStart, onResizeEnd, handles, minWidth, minHeight, maxWidth, maxHeight, disabled, keepAspect, style, children, ...rest }: IrisResizerProps): React.ReactElement;
+
+interface DragState {
+    /** Pointer x in client coordinates. */
+    x: number;
+    /** Pointer y in client coordinates. */
+    y: number;
+    /** Cumulative delta from pointerdown. */
+    dx: number;
+    /** Cumulative delta from pointerdown. */
+    dy: number;
+    /** The active pointer event. */
+    event: PointerEvent;
+}
+interface UseDragOptions {
+    /** The element the drag handle is bound to. */
+    handle: React.RefObject<HTMLElement | null>;
+    /** Drag is only initiated for these pointer buttons. Default `[0]`. */
+    buttons?: number[];
+    onStart?: (state: DragState) => boolean | void;
+    onDrag?: (state: DragState) => void;
+    onEnd?: (state: DragState) => void;
+    disabled?: boolean;
+}
+/**
+ * Bind pointer-driven drag handlers to an element. Uses `setPointerCapture`
+ * so the drag continues even after the pointer leaves the element. Cancels
+ * on `pointercancel`.
+ *
+ * Pure pointer events — works for mouse, touch, and pen.
+ */
+declare function useDrag(options: UseDragOptions): void;
+
+interface IrisSelectItem<T = unknown> {
+    value: T;
+    label?: string;
+    disabled?: boolean;
+}
+
+type IrisSelectSize = Size;
+interface IrisSelectProps<T = unknown> {
+    items: IrisSelectItem<T>[];
+    value?: T;
+    defaultValue?: T;
+    onValueChange?: (value: T) => void;
+    placeholder?: string;
+    size?: IrisSelectSize;
+    disabled?: boolean;
+    placement?: Placement;
+    invalid?: boolean;
+    /** id forwarded to the trigger button. Set by `IrisFormField`. */
+    id?: string;
+    /** Forwarded as `aria-describedby` on the trigger. Set by `IrisFormField`. */
+    ariaDescribedby?: string;
+    /** Custom render for the trigger button. Receives current label + open state. */
+    renderTrigger?: (state: {
+        value: T | undefined;
+        label: string;
+        open: boolean;
+    }) => React.ReactNode;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Single-select dropdown. Composes Popover (positioning + dismiss) with an
+ * inline listbox (keyboard nav + selection). Arrow-key, typeahead, Home/End, and
+ * Enter/Space navigation are single-sourced in `createKeyboardNav` (core).
+ *
+ * @example
+ *   <IrisSelect
+ *     items={[{ value: 'a', label: 'Apple' }, { value: 'b', label: 'Banana' }]}
+ *     value={fruit}
+ *     onValueChange={setFruit}
+ *     placeholder="Pick a fruit"
+ *   />
+ */
+declare function IrisSelect<T = unknown>({ items, value: valueProp, defaultValue, onValueChange, placeholder, size, disabled, placement, invalid, id, ariaDescribedby, renderTrigger, style, className, }: IrisSelectProps<T>): React.ReactElement;
+
+type IrisTableSortDirection = 'asc' | 'desc';
+/** Map of column key → current width in px (after any resizing). */
+type IrisTableColumnWidths = Record<string, number>;
+type IrisTableEditor = 'text' | 'number';
+/** Aggregation op for a column's summary/footer cell. */
+type IrisTableAggregateOp = 'sum' | 'avg' | 'min' | 'max' | 'count';
+interface IrisTableVirtualOptions {
+    /** Per-row height in px (uniform). */
+    itemHeight: number;
+    /** Viewport height. Number → px; string → CSS length. */
+    height: number | string;
+    /** Extra rows rendered above and below the viewport. */
+    buffer?: number;
+}
+interface IrisTableSortState {
+    key: string;
+    direction: IrisTableSortDirection;
+}
+interface IrisTableColumn<Row = Record<string, unknown>> {
+    key: string;
+    title: string;
+    /** Path inside the row to read the cell value from. Defaults to `key`. */
+    dataIndex?: keyof Row | string;
+    sortable?: boolean;
+    width?: number | string;
+    /** Minimum width (px) when resizing. Default 60. */
+    minWidth?: number;
+    /** Maximum width (px) when resizing. Default Infinity. */
+    maxWidth?: number;
+    align?: 'left' | 'center' | 'right';
+    /** Freeze this column to an edge during horizontal scroll (position: sticky). */
+    pinned?: 'left' | 'right';
+    /** Allow double-click inline editing of this column's cells. */
+    editable?: boolean;
+    /** Editor kind. Default `'text'`. */
+    editor?: IrisTableEditor;
+    /**
+     * Validate a draft value before it commits. Return an error message to
+     * REJECT the edit (the editor stays open, shows the message, and is marked
+     * `aria-invalid`); return `null`/`undefined` to accept. Receives the parsed
+     * value (a number for the `'number'` editor) and the row being edited.
+     */
+    validate?: (value: unknown, row: Row) => string | null | undefined;
+    /**
+     * Aggregate this column in the table's summary/footer row. Any column with a
+     * `summary` op makes the footer row appear; columns without one render blank.
+     */
+    summary?: IrisTableAggregateOp;
+    /**
+     * Format this column's summary value. Receives the aggregated number and the
+     * rows it was computed over; defaults to the number's string form.
+     */
+    renderSummary?: (value: number, rows: Row[]) => React.ReactNode;
+    /**
+     * Child columns, making this a HEADER GROUP that spans them in a multi-level
+     * header. A column with `children` is not a data column itself — its leaf
+     * descendants render the body. Omit for a normal (leaf) column.
+     */
+    children?: IrisTableColumn<Row>[];
+    /** Custom comparator for sorting; defaults to native `<`. */
+    sorter?: (a: Row, b: Row) => number;
+    /** Custom render for cell content. */
+    render?: (value: unknown, row: Row, rowIndex: number) => React.ReactNode;
+}
+interface IrisTableCellEditEvent<Row = Record<string, unknown>> {
+    row: Row;
+    column: IrisTableColumn<Row>;
+    oldValue: unknown;
+    newValue: unknown;
+    rowIndex: number;
+}
+
+interface IrisTableProps<Row extends Record<string, unknown> = Record<string, unknown>> {
+    columns: IrisTableColumn<Row>[];
+    data: Row[];
+    /** Field to use as the row key. */
+    rowKey?: string;
+    /** Selection mode. */
+    selectable?: 'none' | 'single' | 'multi';
+    selection?: Array<string | number>;
+    defaultSelection?: Array<string | number>;
+    onSelectionChange?: (next: Array<string | number>) => void;
+    sort?: IrisTableSortState | null;
+    defaultSort?: IrisTableSortState | null;
+    onSortChange?: (next: IrisTableSortState | null) => void;
+    striped?: boolean;
+    bordered?: boolean;
+    /** Enable column resizing (drag the header's trailing edge or focus + arrow keys). */
+    resizableColumns?: boolean;
+    /** Controlled per-column pixel widths, keyed by column `key`. */
+    columnWidths?: IrisTableColumnWidths;
+    defaultColumnWidths?: IrisTableColumnWidths;
+    onColumnWidthsChange?: (next: IrisTableColumnWidths) => void;
+    /** Called when an inline-editable cell is committed with a changed value. */
+    onCellEdit?: (event: IrisTableCellEditEvent<Row>) => void;
+    /**
+     * Render an expandable detail panel beneath a row. Providing this adds a
+     * leading expand-toggle column; clicking it reveals a full-width detail row.
+     * (Not applied in the virtual-scroll path.)
+     */
+    renderDetail?: (row: Row, rowIndex: number) => React.ReactNode;
+    /** Which rows can expand a detail panel. Defaults to all rows when `renderDetail` is set. */
+    rowExpandable?: (row: Row, rowIndex: number) => boolean;
+    /** Initially-expanded row keys (uncontrolled). Shared by detail rows + tree rows. */
+    defaultExpandedRowKeys?: Array<string | number>;
+    /** Notified with the expanded row keys whenever they change. */
+    onExpandedRowsChange?: (keys: Array<string | number>) => void;
+    /**
+     * Read a row's child rows to render the table as a TREE. Providing this enables
+     * tree mode: `data` is treated as the root rows, each row's first cell gains a
+     * depth indent + an expand/collapse toggle (when it has children), and the
+     * expand state reuses `defaultExpandedRowKeys`/`onExpandedRowsChange`. Column
+     * sort reorders siblings hierarchically (each level sorted, structure kept),
+     * and tree rows virtualize like flat rows when `virtualScroll` is set (unless
+     * `renderDetail` is also used, since detail panels are variable-height).
+     */
+    getSubRows?: (row: Row) => Row[] | undefined;
+    /**
+     * Enable WAI-ARIA grid keyboard navigation: the table becomes `role="grid"`
+     * and Arrow / Home / End / Page Up·Down move a roving cell focus across the
+     * data cells. Off by default; opt-in and additive (no effect on mouse / Tab
+     * behavior). Pairs best without virtualization (the focused cell must be
+     * rendered) and does not hijack keystrokes while a cell is being edited.
+     */
+    keyboardNavigation?: boolean;
+    /** Enable virtual scrolling for the body (renders only the visible window). */
+    virtualScroll?: IrisTableVirtualOptions;
+    /**
+     * Render only the horizontally-visible columns (plus pinned + a small
+     * overscan) for very wide tables. Needs numeric column widths; the table
+     * becomes a horizontal scroll container. Off-screen grid tracks stay sized,
+     * so alignment, resize, and pinned columns keep working.
+     */
+    columnVirtualization?: boolean;
+    /**
+     * Enable rectangular cell-range selection (Excel-style). Click starts a
+     * range; Shift+Click or Shift+Arrow extends it; Escape clears it.
+     * Cells within the range get `data-iris-cell-selected="true"`.
+     */
+    cellRange?: boolean;
+    /** Empty state node (replaces the row body when `data` is empty). */
+    emptyState?: React.ReactNode;
+    /** Show the loading state instead of rows. */
+    loading?: boolean;
+    /** Show the error state instead of rows (takes precedence over loading). */
+    error?: boolean;
+    /** Custom loading-state node (defaults to the localized `table.loading`). */
+    loadingState?: React.ReactNode;
+    /** Custom error-state node (defaults to the localized `table.error`). */
+    errorState?: React.ReactNode;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Data-driven table. Renders as a CSS-grid layout (no native `<table>`) so it
+ * can support future virtual scroll / column resize uniformly. Wires ARIA
+ * roles (`table` / `row` / `columnheader` / `cell`) for screen readers.
+ *
+ * Sortable columns cycle `none → asc → desc → none` on click.
+ */
+declare function IrisTable<Row extends Record<string, unknown>>({ columns, data, rowKey, selectable, selection: selectionProp, defaultSelection, onSelectionChange, sort: sortProp, defaultSort, onSortChange, striped, bordered, resizableColumns, columnWidths: columnWidthsProp, defaultColumnWidths, onColumnWidthsChange, onCellEdit, renderDetail, rowExpandable, defaultExpandedRowKeys, onExpandedRowsChange, getSubRows, keyboardNavigation, cellRange, virtualScroll, columnVirtualization, emptyState, loading, error, loadingState, errorState, style, className, }: IrisTableProps<Row>): React.ReactElement;
+
+/**
+ * Serialize rows as a CSV string per RFC 4180. Column order determines field
+ * order; cell values are read via `dataIndex` (defaulting to the column key).
+ * Returns a plain string without BOM.
+ */
+declare function exportCsv<Row extends Record<string, unknown>>(rows: readonly Row[], columns: readonly IrisTableColumn<Row>[]): string;
+/**
+ * Trigger a download of the given CSV string. A host `FileSaveHandler` (set via
+ * `setFileSaveHandler`) intercepts it for native save in desktop/mobile shells;
+ * otherwise falls back to the browser `<a download>`. SSR-safe.
+ */
+declare function downloadCsv(filename: string, csv: string): Promise<void>;
+
+/**
+ * Serialize rows to a SpreadsheetML (Excel/LibreOffice-native) XML string —
+ * the dependency-free counterpart to {@link exportCsv}. Column order sets field
+ * order; values read via `dataIndex` (defaulting to `key`).
+ */
+declare function exportExcel<Row extends Record<string, unknown>>(rows: readonly Row[], columns: readonly IrisTableColumn<Row>[], options?: SpreadsheetXmlOptions): string;
+/**
+ * Trigger a download of the given SpreadsheetML string. A host `FileSaveHandler`
+ * (set via `setFileSaveHandler`) intercepts it for native save in desktop/mobile
+ * shells; otherwise falls back to the browser `<a download>`. SSR-safe.
+ */
+declare function downloadExcel(filename: string, xml: string): Promise<void>;
+
+type IrisVirtualScrollAlign = 'start' | 'center' | 'end';
+interface IrisVirtualScrollHandle {
+    scrollToIndex: (index: number, align?: IrisVirtualScrollAlign) => void;
+    /** Imperatively scroll to a pixel offset (clamped to the scrollable range). */
+    scrollToOffset: (offset: number) => void;
+    refresh: () => void;
+}
+interface IrisVirtualScrollProps<T = unknown> {
+    items: readonly T[];
+    /**
+     * Per-item height in px. A number means every row shares that height; pass a
+     * `(index) => px` function for known variable heights (memoize it); or
+     * `'auto'` to measure rendered rows via `ResizeObserver` and cache them —
+     * no need to know heights ahead of time (wrapped text, expandable rows).
+     */
+    itemHeight: number | ((index: number) => number) | 'auto';
+    /** Initial row-height estimate used before measurement, when `itemHeight="auto"`. */
+    estimatedItemHeight?: number;
+    /** Viewport height. Number → px; string → CSS length passed through. */
+    height?: number | string;
+    /** Number of extra rows to render above and below the viewport. */
+    buffer?: number;
+    /** Stable key per item. Falls back to index. */
+    keyOf?: (item: T, index: number) => string | number;
+    /** Render a single item. */
+    renderItem: (item: T, index: number) => React.ReactNode;
+    onScroll?: (scrollTop: number) => void;
+    onRangeChange?: (range: {
+        start: number;
+        end: number;
+    }) => void;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Virtual scroller. Renders only the visible window of items plus a
+ * configurable buffer above and below. Vertical-only. `itemHeight` may be a
+ * fixed number, a `(index) => px` function for variable-height rows, or
+ * `'auto'` to measure rendered rows.
+ *
+ * Internally driven by the stateful core {@link createVirtualizer}: a single
+ * controller owns the measured-size cache (keyed by item, so a row's real
+ * height survives scroll/reorder), the offset tree (O(log n) total/offset/
+ * lower-bound — no O(n) rebuild per scroll), and `scrollToIndex`/`scrollToOffset`.
+ * At a uniform `itemHeight` the visible window is identical to the bare math, so
+ * the public props/output are unchanged.
+ */
+declare const IrisVirtualScroll: <T>(props: IrisVirtualScrollProps<T> & {
+    ref?: React.Ref<IrisVirtualScrollHandle>;
+}) => React.ReactElement;
+
+interface IrisCalendarProps {
+    value?: Date | null;
+    defaultValue?: Date | null;
+    onValueChange?: (next: Date | null) => void;
+    /** Initial visible month (defaults to selected value or today). */
+    defaultMonth?: Date;
+    min?: Date;
+    max?: Date;
+    /** 0–6, 0 = Sunday. Default 0. */
+    weekStartsOn?: number;
+    locale?: string;
+    disabled?: boolean;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Month-view calendar. Single-date selection only. Keyboard:
+ *   - Arrow keys move focus
+ *   - Home / End jump to start/end of week
+ *   - PageUp / PageDown move by month
+ *   - Enter / Space select
+ */
+declare function IrisCalendar({ value: valueProp, defaultValue, onValueChange, defaultMonth, min, max, weekStartsOn, locale, disabled, style, className, }: IrisCalendarProps): React.ReactElement;
+
+interface IrisDatePickerProps {
+    value?: Date | null;
+    defaultValue?: Date | null;
+    onValueChange?: (next: Date | null) => void;
+    min?: Date;
+    max?: Date;
+    weekStartsOn?: number;
+    locale?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    invalid?: boolean;
+    placement?: Placement;
+    /** id forwarded to the trigger. Set by `IrisFormField`. */
+    id?: string;
+    /** Forwarded as `aria-describedby` on the trigger. Set by `IrisFormField`. */
+    ariaDescribedby?: string;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Date picker: button-styled trigger + Popover + Calendar. On selection the
+ * popover auto-closes. Use `IrisCalendar` directly when you want it inline.
+ */
+declare function IrisDatePicker({ value: valueProp, defaultValue, onValueChange, min, max, weekStartsOn, locale, placeholder, disabled, invalid, placement, id, ariaDescribedby, style, className, }: IrisDatePickerProps): React.ReactElement;
+
+interface IrisTreeNode {
+    /** Stable unique identifier. */
+    id: string;
+    /** Display label. */
+    label: string;
+    /** Eagerly populated children. */
+    children?: IrisTreeNode[];
+    /** When true, this node is a leaf and the expand affordance is hidden. */
+    isLeaf?: boolean;
+    /** Disabled — non-selectable. */
+    disabled?: boolean;
+    /**
+     * Lazy children loader. Called the first time the node is expanded.
+     * Resolves to the children array; the tree caches the result so subsequent
+     * expansions are instant. On rejection the node shows an error state and
+     * collapses. (Parity with the Vue adapter's `IrisTreeNode`.)
+     */
+    loadChildren?: () => Promise<IrisTreeNode[]>;
+}
+type IrisTreeSelectionMode = 'none' | 'single' | 'multi';
+
+interface IrisTreeProps {
+    nodes: IrisTreeNode[];
+    expanded?: string[];
+    defaultExpanded?: string[];
+    onExpandedChange?: (next: string[]) => void;
+    selected?: string[];
+    defaultSelected?: string[];
+    onSelectedChange?: (next: string[]) => void;
+    selectionMode?: IrisTreeSelectionMode;
+    /**
+     * Show a checkbox per node with parent/child cascade + indeterminate
+     * (tri-state) propagation, independent of `selectionMode`. Driven by the
+     * framework-agnostic `createTreeSelection`.
+     */
+    checkable?: boolean;
+    /** Initially checked node ids (uncontrolled; reconciled through the cascade). */
+    defaultChecked?: string[];
+    /** Notified with the fully-reconciled checked node ids on every check change. */
+    onCheckedChange?: (checked: string[]) => void;
+    ariaLabel?: string;
+    /** Show the loading state instead of nodes. */
+    loading?: boolean;
+    /** Show the error state instead of nodes (takes precedence over loading). */
+    error?: boolean;
+    /** Custom empty-state node (defaults to the localized `tree.empty`). */
+    emptyState?: React.ReactNode;
+    /** Custom loading-state node (defaults to the localized `tree.loading`). */
+    loadingState?: React.ReactNode;
+    /** Custom error-state node (defaults to the localized `tree.error`). */
+    errorState?: React.ReactNode;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Tree control. Renders a hierarchy of `IrisTreeNode`s with expand/collapse,
+ * single/multi selection, and optional lazy-loaded children. WAI-ARIA Tree
+ * pattern: root `role="tree"`, each node `role="treeitem"`, roving tabindex.
+ *
+ * Keyboard:
+ *   - ↓/↑ : move active node
+ *   - → : expand (or move into first child)
+ *   - ← : collapse (or move to parent)
+ *   - Enter / Space : (de)select active node
+ *   - Home / End : first / last visible node
+ *
+ * Async lifecycle: pass `loading` / `error` (and empty `nodes`) to render the
+ * animated loading / error / empty state in place of the tree. Per-node
+ * `loadChildren` lazy loading is independent of this top-level state. Semantic
+ * parity with the Vue adapter's `IrisTree`.
+ */
+declare function IrisTree({ nodes, expanded: expandedProp, defaultExpanded, onExpandedChange, selected: selectedProp, defaultSelected, onSelectedChange, selectionMode, checkable, defaultChecked, onCheckedChange, ariaLabel, loading, error, emptyState, loadingState, errorState, style, className, }: IrisTreeProps): React.ReactElement;
+
+interface IrisListItem<T = unknown> {
+    value: T;
+    label?: string;
+    disabled?: boolean;
+}
+interface IrisListProps<T = unknown> {
+    items: IrisListItem<T>[];
+    /** Selected value(s). For multi mode, pass an array. */
+    value?: T | T[] | null;
+    defaultValue?: T | T[] | null;
+    onValueChange?: (next: T | T[] | null) => void;
+    onSelect?: (item: IrisListItem<T>) => void;
+    multi?: boolean;
+    /** Loop arrow nav at boundaries. Default true. */
+    loop?: boolean;
+    ariaLabel?: string;
+    /** Show the loading state instead of items. */
+    loading?: boolean;
+    /** Show the error state instead of items (takes precedence over loading). */
+    error?: boolean;
+    /** Custom empty-state node (defaults to the localized `list.empty`). */
+    emptyState?: React.ReactNode;
+    /** Custom loading-state node (defaults to the localized `list.loading`). */
+    loadingState?: React.ReactNode;
+    /** Custom error-state node (defaults to the localized `list.error`). */
+    errorState?: React.ReactNode;
+    /** Custom render per item. */
+    renderItem?: (item: IrisListItem<T>, state: {
+        selected: boolean;
+        active: boolean;
+        index: number;
+    }) => React.ReactNode;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Generic selectable list — foundation for `IrisSelect` content, dropdowns,
+ * command palettes, etc. Implements the WAI-ARIA Listbox pattern:
+ *
+ *   - `role="listbox"` (with `aria-multiselectable` when `multi`)
+ *   - Roving tabindex (one item has tabindex=0, others -1)
+ *   - Arrow keys / Home / End move focus via `createKeyboardNav` (core)
+ *   - Enter / Space (de)select
+ *
+ * Keyboard logic is single-sourced in `@iris-ui-kit/core` — this adapter only
+ * bridges the returned actions to DOM focus and selection callbacks.
+ *
+ * Async lifecycle: pass `loading` / `error` (and an empty `items`) to render
+ * the animated loading / error / empty state in place of options. State
+ * precedence and entry animation come from {@link useDataState}.
+ */
+declare function IrisList<T = unknown>({ items, value: valueProp, defaultValue, onValueChange, onSelect, multi, loop, ariaLabel, loading, error, emptyState, loadingState, errorState, renderItem, style, className, }: IrisListProps<T>): React.ReactElement;
+
+interface IrisFileUploadFile {
+    file: File;
+    name: string;
+    size: number;
+    type: string;
+}
+declare function formatBytes(bytes: number): string;
+type IrisFileUploadRejectReason = 'size' | 'count' | 'type';
+interface IrisFileUploadRejection {
+    file: IrisFileUploadFile;
+    reason: IrisFileUploadRejectReason;
+}
+interface IrisFileUploadProps {
+    value?: IrisFileUploadFile[];
+    defaultValue?: IrisFileUploadFile[];
+    onValueChange?: (files: IrisFileUploadFile[]) => void;
+    onAccept?: (files: IrisFileUploadFile[]) => void;
+    onReject?: (entries: IrisFileUploadRejection[]) => void;
+    /** MIME type filter (forwarded + used to filter dropped files). */
+    accept?: string;
+    multiple?: boolean;
+    /** Max file size in bytes. 0 = unlimited. */
+    maxSize?: number;
+    /** Max simultaneous files. 0 = unlimited. */
+    maxFiles?: number;
+    disabled?: boolean;
+    /** Idle dropzone label. */
+    label?: string;
+    /** id forwarded to the hidden input. Set by `IrisFormField`. */
+    id?: string;
+    /** Custom render for the file list. Receives `{ files, remove }`. */
+    renderList?: (state: {
+        files: IrisFileUploadFile[];
+        remove: (index: number) => void;
+    }) => React.ReactNode;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * File-upload dropzone. Wraps a hidden `<input type="file">` with a
+ * click-to-browse + drag-and-drop surface. Validates via `accept`, `maxSize`,
+ * `maxFiles`; rejected files surface via `onReject`.
+ */
+declare function IrisFileUpload({ value: valueProp, defaultValue, onValueChange, onAccept, onReject, accept, multiple, maxSize, maxFiles, disabled, label, id, renderList, style, className, }: IrisFileUploadProps): React.ReactElement;
+
+interface IrisMenuProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (next: boolean) => void;
+    placement?: Placement;
+    offset?: number;
+    children?: React.ReactNode;
+}
+/**
+ * Root of a (potentially nested) menu. Provides the "close everything"
+ * channel so picking a leaf in a deeply nested branch closes the whole tree.
+ *
+ * Use `IrisMenuSub` inside the content to declare nested submenus.
+ */
+declare function IrisMenu({ open: openProp, defaultOpen, onOpenChange, placement, offset, children, }: IrisMenuProps): React.ReactElement;
+
+interface IrisMenuTriggerProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'children'> {
+    asChild?: boolean;
+    children?: React.ReactNode;
+}
+/**
+ * The trigger that toggles the menu open/closed. Renders as a `<button>` (or
+ * custom via `asChild`) with `aria-haspopup="menu"`. Opens on click,
+ * ArrowDown, Enter, or Space.
+ */
+declare const IrisMenuTrigger: React.ForwardRefExoticComponent<IrisMenuTriggerProps & React.RefAttributes<HTMLElement>>;
+
+interface IrisMenuContentProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    portalTarget?: HTMLElement | false;
+    children?: React.ReactNode;
+}
+/**
+ * Menu surface (`role="menu"`). Handles ArrowUp/Down/Home/End nav across all
+ * `[role="menuitem"]` descendants (including those inside submenu triggers).
+ * Closes on outside click, Escape, and Tab.
+ *
+ * Keyboard navigation is single-sourced in `@iris-ui-kit/core`'s
+ * {@link createKeyboardNav} — this adapter only bridges the returned actions
+ * to DOM focus.
+ */
+declare const IrisMenuContent: React.ForwardRefExoticComponent<IrisMenuContentProps & React.RefAttributes<HTMLDivElement>>;
+
+interface IrisMenuItemProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onSelect'> {
+    disabled?: boolean;
+    /** Skip closing the menu on select (e.g. for sub-actions). */
+    keepOpen?: boolean;
+    /** Triggered on click or Enter/Space. */
+    onSelect?: (event: React.SyntheticEvent) => void;
+}
+/**
+ * An individual selectable item in a menu. Renders as a `role="menuitem"` `<div>`.
+ * Calls `onSelect`, then closes the root menu (unless `keepOpen`). Disabled
+ * items are skipped by keyboard navigation.
+ */
+declare const IrisMenuItem: React.ForwardRefExoticComponent<IrisMenuItemProps & React.RefAttributes<HTMLDivElement>>;
+type IrisMenuSeparatorProps = React.HTMLAttributes<HTMLDivElement>;
+/**
+ * A visual separator within a menu — renders a `role="separator"` `<div>`.
+ */
+declare const IrisMenuSeparator: React.ForwardRefExoticComponent<IrisMenuSeparatorProps & React.RefAttributes<HTMLDivElement>>;
+
+interface IrisMenuSubProps {
+    label?: React.ReactNode;
+    portalTarget?: HTMLElement | false;
+    children?: React.ReactNode;
+}
+/**
+ * Nested submenu. Renders its own trigger (a `[role="menuitem"]` inside the
+ * parent menu) and floating content panel. Opens on hover (with a short
+ * delay) and on ArrowRight / Enter; closes on ArrowLeft.
+ *
+ * Inherits `closeRoot` from the surrounding `IrisMenu` so picking a leaf
+ * collapses the whole tree.
+ */
+declare function IrisMenuSub({ label, portalTarget, children, }: IrisMenuSubProps): React.ReactElement;
+
+interface MenuContextValue {
+    open: boolean;
+    setOpen: (next: boolean) => void;
+    triggerRef: React.MutableRefObject<HTMLElement | null>;
+    contentRef: React.MutableRefObject<HTMLElement | null>;
+    contentId: string;
+    placement: Placement;
+    offset: number;
+    /** Close the *root* menu — propagates to nested submenus. */
+    closeRoot: () => void;
+}
+declare const MenuContext: React.Context<MenuContextValue | null>;
+declare function useMenuContext(componentName: string): MenuContextValue;
+
+type IrisBannerTone = 'info' | 'success' | 'warning' | 'danger' | 'neutral';
+interface IrisBannerProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    tone?: IrisBannerTone;
+    closable?: boolean;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (next: boolean) => void;
+    /** Use `position: sticky; top: 0;`. */
+    sticky?: boolean;
+    /** Optional icon slot rendered before the content. */
+    icon?: React.ReactNode;
+    /** Optional actions slot rendered after the content. */
+    actions?: React.ReactNode;
+    children?: React.ReactNode;
+}
+/**
+ * Edge-to-edge announcement bar — typically pinned to the top of the layout.
+ * Distinct from `IrisAlert`:
+ *   1. Edge-to-edge (full width) instead of a contained card
+ *   2. Optional `sticky` positioning
+ *   3. Tighter vertical padding
+ */
+declare function IrisBanner({ tone, closable, open: openProp, defaultOpen, onOpenChange, sticky, icon, actions, style, children, ...rest }: IrisBannerProps): React.ReactElement | null;
+
+type IrisTimePickerFormat = '12h' | '24h';
+interface IrisTimeValue {
+    hours: number;
+    minutes: number;
+}
+interface IrisTimePickerProps {
+    value?: IrisTimeValue | null;
+    defaultValue?: IrisTimeValue;
+    onValueChange?: (value: IrisTimeValue) => void;
+    format?: IrisTimePickerFormat;
+    /** Step in minutes for the minute input (1, 5, 10, 15, 30). */
+    minuteStep?: number;
+    disabled?: boolean;
+    invalid?: boolean;
+    /** id forwarded to the hours input. Set by `IrisFormField`. */
+    id?: string;
+    /** Forwarded as `aria-describedby` on the hours input. Set by `IrisFormField`. */
+    ariaDescribedby?: string;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Time picker rendered as two zero-padded number inputs (hours + minutes)
+ * plus an optional AM/PM toggle for 12h format. Internal value is always
+ * 24-hour `{ hours, minutes }`.
+ */
+declare function IrisTimePicker({ value: valueProp, defaultValue, onValueChange, format, minuteStep, disabled, invalid, id, ariaDescribedby, style, className, }: IrisTimePickerProps): React.ReactElement;
+
+interface IrisDateRange {
+    start: Date | null;
+    end: Date | null;
+}
+interface IrisDateRangePickerProps {
+    value?: IrisDateRange | null;
+    defaultValue?: IrisDateRange;
+    onValueChange?: (next: IrisDateRange) => void;
+    min?: Date;
+    max?: Date;
+    weekStartsOn?: number;
+    locale?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    invalid?: boolean;
+    placement?: Placement;
+    id?: string;
+    ariaDescribedby?: string;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Range date picker. Trigger displays `start → end`; popover contains two
+ * month calendars (current + next).
+ *
+ * Click order: first click → sets `start`. Second click → sets `end`
+ * (auto-swaps if before `start`). Popover closes on completion.
+ */
+declare function IrisDateRangePicker({ value: valueProp, defaultValue, onValueChange, min, max, weekStartsOn, locale, placeholder, disabled, invalid, placement, id, ariaDescribedby, style, className, }: IrisDateRangePickerProps): React.ReactElement;
+
+type IrisSliderOrientation = 'horizontal' | 'vertical';
+interface IrisSliderProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange' | 'defaultValue'> {
+    value?: number;
+    defaultValue?: number;
+    onChange?: (next: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    orientation?: IrisSliderOrientation;
+    /** Accessible label for screen readers. */
+    label?: string;
+}
+/**
+ * Numeric slider with keyboard + pointer support.
+ *
+ * Keyboard:
+ *   ←/↓ −step  ·  →/↑ +step  ·  Home min  ·  End max  ·  PgUp/PgDn ±step×10
+ */
+declare function IrisSlider({ value: valueProp, defaultValue, onChange, min, max, step, disabled, orientation, label, style, ...rest }: IrisSliderProps): React.ReactElement;
+
+type IrisRangeSliderValue = readonly [number, number];
+interface IrisRangeSliderProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange' | 'defaultValue'> {
+    value?: IrisRangeSliderValue;
+    defaultValue?: IrisRangeSliderValue;
+    onChange?: (next: IrisRangeSliderValue) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    labelStart?: string;
+    labelEnd?: string;
+}
+/**
+ * Two-handle numeric range slider. Value is `[start, end]` with `start <= end`;
+ * the two handles never cross.
+ */
+declare function IrisRangeSlider({ value: valueProp, defaultValue, onChange, min, max, step, disabled, labelStart, labelEnd, style, ...rest }: IrisRangeSliderProps): React.ReactElement;
+
+interface IrisColorPickerProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange' | 'defaultValue'> {
+    /** HEX string (`#rgb` / `#rrggbb` / `#rrggbbaa`). */
+    value?: string;
+    defaultValue?: string;
+    onChange?: (next: string) => void;
+    /** Include the alpha strip + alpha input. Default false. */
+    showAlpha?: boolean;
+    disabled?: boolean;
+}
+/**
+ * Color picker: SV pad + hue strip (+ optional alpha) with HEX + R/G/B(/A) inputs.
+ * Binds a HEX string (`#rgb` / `#rrggbb` / `#rrggbbaa`) via `value` / `onChange`.
+ *
+ * Internal state is HSVA so hue survives grayscale RGB (black/white) without resetting —
+ * mirrors the Vue adapter; the math (`colorUtils`) is shared verbatim, framework-agnostic.
+ */
+declare function IrisColorPicker({ value, defaultValue, onChange, showAlpha, disabled, style, ...rest }: IrisColorPickerProps): React.ReactElement;
+
+interface IrisCommandItem {
+    /** Stable unique id. */
+    id: string;
+    /** Display label. */
+    label: string;
+    /** Searchable extra terms (e.g. synonyms). */
+    keywords?: string[];
+    /** Optional grouping. Items with the same `group` cluster together. */
+    group?: string;
+    /** Icon prefix (string emoji or node). */
+    icon?: string;
+    /** Shortcut hint shown on the right of the row. */
+    shortcut?: string;
+    disabled?: boolean;
+    /** Triggered on Enter / click. */
+    action?: () => void;
+}
+/**
+ * Default fuzzy match: a query matches an item when each query character
+ * appears in order in the item label or keywords. Case-insensitive.
+ * Returns a score (lower = better) or null if no match.
+ */
+declare function defaultFilter(query: string, item: IrisCommandItem): number | null;
+
+interface IrisCommandPaletteProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onSelect'> {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    items: IrisCommandItem[];
+    placeholder?: string;
+    /** Empty state text when no item matches. */
+    emptyText?: string;
+    /** Custom filter; default is a tolerant subsequence/fuzzy match. */
+    filter?: (query: string, item: IrisCommandItem) => number | null;
+    onSelect?: (item: IrisCommandItem) => void;
+}
+/**
+ * Command palette: searchable, keyboard-driven action launcher. Built on the
+ * modal-utils suite (scroll lock + focus trap). Pattern: open via shortcut
+ * (consumer wires the listener), type to filter, ↑/↓ to navigate, Enter to
+ * execute the focused item, Escape to dismiss.
+ */
+declare function IrisCommandPalette({ open, onOpenChange, items, placeholder, emptyText, filter, onSelect, style, ...rest }: IrisCommandPaletteProps): React.ReactElement | null;
+
+export { AccordionContext, type AccordionContextValue, DialogContext, type DialogContextValue, type DragState, DrawerContext, type DrawerContextValue, DropdownContext, type DropdownContextValue, IrisAccordion, IrisAccordionItem, type IrisAccordionItemProps, type IrisAccordionProps, type IrisAccordionValue, IrisAffix, type IrisAffixProps, IrisAlert, type IrisAlertProps, type IrisAlertTone, IrisAnchor, type IrisAnchorItem, type IrisAnchorProps, IrisAspectRatio, type IrisAspectRatioProps, IrisAvatar, type IrisAvatarProps, type IrisAvatarShape, type IrisAvatarSize, IrisBackTop, type IrisBackTopProps, IrisBadge, type IrisBadgeProps, type IrisBadgeSize, type IrisBadgeTone, type IrisBadgeVariant, IrisBanner, type IrisBannerProps, type IrisBannerTone, IrisBreadcrumb, IrisBreadcrumbItem, type IrisBreadcrumbItemProps, type IrisBreadcrumbProps, IrisButton, type IrisButtonProps, type IrisButtonSize, type IrisButtonType, type IrisButtonVariant, IrisCalendar, type IrisCalendarProps, IrisCard, type IrisCardPadding, type IrisCardProps, type IrisCardVariant, IrisCarousel, type IrisCarouselProps, IrisCascader, type IrisCascaderNode, type IrisCascaderProps, type IrisCascaderSize, IrisCheckbox, type IrisCheckboxProps, type IrisCheckboxSize, type IrisCheckboxValue, IrisChip, type IrisChipProps, type IrisChipSize, type IrisChipTone, type IrisChipVariant, IrisColorPicker, type IrisColorPickerProps, IrisCombobox, type IrisComboboxOption, type IrisComboboxProps, type IrisComboboxSize, type IrisCommandItem, IrisCommandPalette, type IrisCommandPaletteProps, IrisCopyButton, type IrisCopyButtonProps, type IrisCopyButtonSize, IrisCountdown, type IrisCountdownProps, type IrisCountdownSize, IrisDatePicker, type IrisDatePickerProps, type IrisDateRange, IrisDateRangePicker, type IrisDateRangePickerProps, IrisDescriptions, type IrisDescriptionsItem, type IrisDescriptionsLayout, type IrisDescriptionsProps, IrisDialog, IrisDialogClose, type IrisDialogCloseProps, IrisDialogContent, type IrisDialogContentProps, IrisDialogDescription, type IrisDialogDescriptionProps, type IrisDialogProps, IrisDialogTitle, type IrisDialogTitleProps, IrisDialogTrigger, type IrisDialogTriggerProps, IrisDivider, type IrisDividerOrientation, type IrisDividerProps, type IrisDividerSpacing, IrisDragger, type IrisDraggerBounds, type IrisDraggerPosition, type IrisDraggerProps, IrisDrawer, IrisDrawerClose, type IrisDrawerCloseProps, IrisDrawerContent, type IrisDrawerContentProps, type IrisDrawerProps, type IrisDrawerSide, IrisDrawerTitle, type IrisDrawerTitleProps, IrisDrawerTrigger, type IrisDrawerTriggerProps, IrisDropdown, IrisDropdownItem, type IrisDropdownItemProps, IrisDropdownMenu, type IrisDropdownMenuProps, type IrisDropdownProps, IrisDropdownSeparator, type IrisDropdownSeparatorProps, IrisDropdownTrigger, type IrisDropdownTriggerProps, IrisEmptyState, type IrisEmptyStateProps, IrisFieldset, type IrisFieldsetProps, IrisFileUpload, type IrisFileUploadFile, type IrisFileUploadProps, type IrisFileUploadRejectReason, type IrisFileUploadRejection, IrisFloatButton, type IrisFloatButtonAction, type IrisFloatButtonProps, type IrisFloatButtonShape, IrisFormField, type IrisFormFieldProps, IrisGauge, type IrisGaugeProps, type IrisGaugeStatus, IrisIcon, type IrisIconProps, IrisImage, type IrisImageProps, IrisInput, type IrisInputProps, type IrisInputSize, type IrisInputType, IrisKbd, type IrisKbdProps, type IrisKbdSize, IrisList, type IrisListItem, type IrisListProps, IrisMarquee, type IrisMarqueeDirection, type IrisMarqueeProps, IrisMasonry, type IrisMasonryProps, type IrisMentionOption, IrisMentions, type IrisMentionsProps, IrisMenu, IrisMenuContent, type IrisMenuContentProps, IrisMenuItem, type IrisMenuItemProps, type IrisMenuProps, IrisMenuSeparator, type IrisMenuSeparatorProps, IrisMenuSub, type IrisMenuSubProps, IrisMenuTrigger, type IrisMenuTriggerProps, IrisNumberInput, type IrisNumberInputProps, type IrisNumberInputSize, IrisOtpInput, type IrisOtpInputProps, type IrisOtpInputSize, type IrisOtpInputType, IrisPagination, type IrisPaginationProps, type IrisPaginationSize, IrisPasswordInput, type IrisPasswordInputProps, IrisPopover, IrisPopoverContent, type IrisPopoverContentProps, type IrisPopoverProps, IrisPopoverTrigger, type IrisPopoverTriggerProps, IrisProgress, IrisProgressCircle, type IrisProgressCircleProps, type IrisProgressCircleStatus, type IrisProgressProps, type IrisProgressSize, type IrisProgressTone, IrisRadio, IrisRadioGroup, type IrisRadioGroupProps, type IrisRadioProps, type IrisRadioSize, IrisRangeSlider, type IrisRangeSliderProps, type IrisRangeSliderValue, IrisRating, type IrisRatingProps, type IrisRatingSize, IrisResizer, type IrisResizerHandle, type IrisResizerProps, type IrisResizerSize, IrisResult, type IrisResultProps, type IrisResultStatus, IrisRibbon, type IrisRibbonPlacement, type IrisRibbonProps, IrisScrollArea, type IrisScrollAreaAxis, type IrisScrollAreaProps, IrisSegmented, type IrisSegmentedOption, type IrisSegmentedProps, type IrisSegmentedSize, IrisSelect, type IrisSelectItem, type IrisSelectProps, type IrisSelectSize, IrisSkeleton, type IrisSkeletonProps, type IrisSkeletonShape, IrisSlider, type IrisSliderOrientation, type IrisSliderProps, IrisSlot, type IrisSlotProps, IrisSpinner, type IrisSpinnerProps, type IrisSpinnerSize, IrisSplitButton, type IrisSplitButtonAction, type IrisSplitButtonProps, type IrisSplitButtonSize, type IrisSplitButtonVariant, IrisSplitter, type IrisSplitterOrientation, type IrisSplitterProps, IrisStatistic, type IrisStatisticProps, type IrisStatisticSize, type IrisStatisticTrend, type IrisStepStatus, IrisStepper, type IrisStepperOrientation, type IrisStepperProps, IrisStepperStep, type IrisStepperStepProps, IrisSwitch, type IrisSwitchProps, type IrisSwitchSize, IrisTable, type IrisTableCellEditEvent, type IrisTableColumn, type IrisTableColumnWidths, type IrisTableEditor, type IrisTableProps, type IrisTableSortDirection, type IrisTableSortState, type IrisTableVirtualOptions, IrisTabs, IrisTabsContent, type IrisTabsContentProps, IrisTabsList, type IrisTabsListProps, type IrisTabsOrientation, type IrisTabsProps, IrisTabsTrigger, type IrisTabsTriggerProps, IrisTagInput, type IrisTagInputProps, IrisTextarea, type IrisTextareaProps, type IrisTextareaSize, IrisTimePicker, type IrisTimePickerFormat, type IrisTimePickerProps, type IrisTimeValue, IrisTimeline, type IrisTimelineItem, type IrisTimelineProps, type IrisTimelineVariant, type IrisToast, type IrisToastInput, type IrisToastPosition, type IrisToastVariant, IrisToastViewport, type IrisToastViewportProps, IrisToggleGroup, IrisToggleGroupItem, type IrisToggleGroupItemProps, type IrisToggleGroupMultipleProps, type IrisToggleGroupOrientation, type IrisToggleGroupProps, type IrisToggleGroupSingleProps, type IrisToggleGroupSize, type IrisToggleGroupType, type IrisToggleGroupValue, type IrisToggleGroupVariant, IrisToolbar, type IrisToolbarOrientation, type IrisToolbarProps, IrisTooltip, type IrisTooltipProps, IrisTour, type IrisTourProps, type IrisTourStep, IrisTransfer, type IrisTransferItem, type IrisTransferProps, IrisTree, type IrisTreeNode, type IrisTreeProps, IrisTreeSelect, type IrisTreeSelectNode, type IrisTreeSelectProps, type IrisTreeSelectSize, type IrisTreeSelectionMode, IrisVirtualScroll, type IrisVirtualScrollAlign, type IrisVirtualScrollHandle, type IrisVirtualScrollProps, IrisVisuallyHidden, type IrisVisuallyHiddenProps, IrisWatermark, type IrisWatermarkProps, MenuContext, type MenuContextValue, PopoverContext, type PopoverContextValue, RadioGroupContext, type RadioGroupContextValue, StepperContext, type StepperContextValue, TabsContext, type TabsContextValue, ToggleGroupContext, type ToggleGroupContextValue, type UseDragOptions, type UseToastReturn, __PROGRESS_STYLE_ID, __SKELETON_STYLE_ID, __SPINNER_STYLE_ID, __resetProgressStyles, __resetSkeletonStyles, __resetSpinnerStyles, clearToasts, defaultFilter, dismissToast, downloadCsv, downloadExcel, exportCsv, exportExcel, formatBytes, formatRemaining, getToasts, pushToast, subscribeToasts, useAccordionContext, useDialogContext, useDrag, useDrawerContext, useDropdownContext, useMachine, useMenuContext, usePopoverContext, useStepperContext, useStore, useStoreSelector, useTabsContext, useToast, useToggleGroupContext };