rich-react-component 0.1.0

package/dist/base/Pagination.d.ts

@@ -0,0 +1,15 @@
+export interface PaginationProps {
+    currentPage: number;
+    pageSize: number;
+    totalItems: number;
+    onPageChange: (page: number) => void;
+    /** How many numbered page buttons to show on each side of the current page. */
+    siblingCount?: number;
+    className?: string;
+}
+/**
+ * UI-only, like DataGrid's other UI concerns — no API calls (doc section
+ * 19). This is what lets it be reused by DataGrid (and later
+ * RemoteDataGrid/SmartDataGrid) regardless of where the rows came from.
+ */
+export declare function Pagination({ currentPage, pageSize, totalItems, onPageChange, siblingCount, className }: PaginationProps): import("react").JSX.Element;

package/dist/base/PasswordInput.d.ts

@@ -0,0 +1,10 @@
+import { InputProps } from './Input';
+export interface PasswordInputProps extends Omit<InputProps, "type" | "endAdornment" | "inputProps"> {
+}
+/**
+ * Reuses Input entirely (controlled/uncontrolled logic, FieldShell,
+ * markup) via Input's `endAdornment`/`inputProps` extension points instead
+ * of building an independent text field (doc section 4). No password
+ * strength infrastructure — just visibility toggling.
+ */
+export declare function PasswordInput(props: PasswordInputProps): import("react").JSX.Element;

package/dist/base/Popover.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+export interface PopoverProps {
+    title?: ReactNode;
+    content: ReactNode;
+    children: ReactNode;
+    placement?: "top" | "bottom";
+    className?: string;
+}
+/** Click-triggered variant of Tooltip — same Popup-reuse rationale (see Tooltip.tsx). */
+export declare function Popover({ title, content, children, placement, className }: PopoverProps): import("react").JSX.Element;

package/dist/base/ProgressBar.d.ts

@@ -0,0 +1,10 @@
+import { BadgeVariant } from './Badge';
+export interface ProgressBarProps {
+    /** 0-100. Values outside that range are clamped. */
+    value: number;
+    variant?: BadgeVariant;
+    /** Show the percentage as text inside the bar. */
+    label?: boolean;
+    className?: string;
+}
+export declare function ProgressBar({ value, variant, label, className }: ProgressBarProps): import("react").JSX.Element;

package/dist/base/RadioButton.d.ts

@@ -0,0 +1,18 @@
+export interface RadioButtonProps<TValue extends string | number = string> {
+    id?: string;
+    name?: string;
+    value: TValue;
+    label?: string;
+    checked: boolean;
+    disabled?: boolean;
+    className?: string;
+    onChange?: (value: TValue) => void;
+}
+/**
+ * A single radio input. Always controlled by `checked` — a lone HTML radio
+ * doesn't have meaningful independent uncontrolled state the way a
+ * checkbox does (mutual exclusivity requires a group), so it's normally
+ * composed by RadioGroup, which owns the actual controlled/uncontrolled
+ * value. Usable standalone by a consumer who wants to manage state itself.
+ */
+export declare function RadioButton<TValue extends string | number = string>({ id, name, value, label, checked, disabled, className, onChange, }: RadioButtonProps<TValue>): import("react").JSX.Element;

package/dist/base/RadioGroup.d.ts

@@ -0,0 +1,14 @@
+import { FieldIdentity, FieldPresentation, FieldState, SelectOption } from './shared/fieldTypes';
+export interface RadioGroupProps<TValue extends string | number = string> extends FieldIdentity, FieldState, FieldPresentation {
+    options: SelectOption<TValue>[];
+    value?: TValue | null;
+    defaultValue?: TValue | null;
+    onChange?: (value: TValue) => void;
+    inline?: boolean;
+}
+/**
+ * Composes RadioButton rather than reproducing radio rendering (doc
+ * section 7) — this is the component that actually owns the group's
+ * controlled/uncontrolled value.
+ */
+export declare function RadioGroup<TValue extends string | number = string>({ options, value, defaultValue, onChange, inline, id, name, disabled, required, className, label, helpText, error, }: RadioGroupProps<TValue>): import("react").JSX.Element;

package/dist/base/Rating.d.ts

@@ -0,0 +1,9 @@
+export interface RatingProps {
+    value?: number;
+    defaultValue?: number;
+    onChange?: (value: number) => void;
+    max?: number;
+    disabled?: boolean;
+    className?: string;
+}
+export declare function Rating({ value, defaultValue, onChange, max, disabled, className }: RatingProps): import("react").JSX.Element;

package/dist/base/Row.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+export interface RowProps {
+    className?: string;
+    children?: ReactNode;
+}
+export declare function Row({ className, children }: RowProps): import("react").JSX.Element;

package/dist/base/Select.d.ts

@@ -0,0 +1,24 @@
+import { FieldIdentity, FieldPresentation, FieldState, SelectOption } from './shared/fieldTypes';
+export interface SelectProps<TValue extends string | number = string> extends FieldIdentity, FieldState, FieldPresentation {
+    options: SelectOption<TValue>[];
+    value?: TValue | null;
+    defaultValue?: TValue | null;
+    onChange?: (value: TValue | null) => void;
+    /**
+     * Presentational-only loading flag, same convention as ComboBox/
+     * AutoComplete/MultiSelect's `loading` prop — Select has no idea *why*
+     * it's loading (doc section 8). Disables the control and shows a
+     * "Loading…" placeholder option; set by RemoteSelect.
+     */
+    loading?: boolean;
+}
+/**
+ * Not remote-aware (doc section 5). Deliberately a native `<select>` rather
+ * than reusing ComboBox's Popup/keyboard-list UI — their UI semantics
+ * genuinely differ (native select already has full built-in keyboard/
+ * screen-reader support, so reusing Popup here would be a *regression*, not
+ * a simplification). The two DO share the same typed option abstraction
+ * (`SelectOption`) and the same FieldShell/useControllableState — that's
+ * the "smallest appropriate abstraction" the doc asks for.
+ */
+export declare function Select<TValue extends string | number = string>({ options, value, defaultValue, onChange, placeholder, loading, id, name, disabled, readOnly, required, className, label, helpText, error, }: SelectProps<TValue>): import("react").JSX.Element;

package/dist/base/Sidebar.d.ts

@@ -0,0 +1,31 @@
+import { ReactNode } from 'react';
+export interface SidebarLeafItem {
+    key: string;
+    label: ReactNode;
+    icon?: ReactNode;
+    href?: string;
+    onClick?: () => void;
+    active?: boolean;
+    disabled?: boolean;
+}
+export interface SidebarGroup {
+    key: string;
+    label: string;
+    items: SidebarLeafItem[];
+    defaultOpen?: boolean;
+}
+export type SidebarSection = SidebarLeafItem | SidebarGroup;
+export interface SidebarProps {
+    sections: SidebarSection[];
+    header?: ReactNode;
+    footer?: ReactNode;
+    className?: string;
+}
+/**
+ * Persistent vertical navigation. Leaf entries render as plain nav links;
+ * grouped/collapsible sections reuse Accordion (doc section 20 — no second
+ * independent collapse implementation) instead of reimplementing open/close
+ * state. Active-state comes from the `active` flag the caller passes in —
+ * routing/URL matching is the consuming app's job (doc section 22).
+ */
+export declare function Sidebar({ sections, header, footer, className }: SidebarProps): import("react").JSX.Element;

package/dist/base/Skeleton.d.ts

@@ -0,0 +1,8 @@
+export interface SkeletonProps {
+    width?: string | number;
+    height?: string | number;
+    circle?: boolean;
+    className?: string;
+}
+/** Uses Bootstrap's built-in `placeholder`/`placeholder-glow` classes rather than inventing a new loading-shimmer animation. */
+export declare function Skeleton({ width, height, circle, className }: SkeletonProps): import("react").JSX.Element;

package/dist/base/Slider.d.ts

@@ -0,0 +1,10 @@
+import { FieldIdentity, FieldPresentation, FieldState } from './shared/fieldTypes';
+export interface SliderProps extends FieldIdentity, FieldState, FieldPresentation {
+    value?: number;
+    defaultValue?: number;
+    onChange?: (value: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+}
+export declare function Slider({ value, defaultValue, onChange, min, max, step, id, name, disabled, required, className, label, helpText, error, }: SliderProps): import("react").JSX.Element;

package/dist/base/Spinner.d.ts

@@ -0,0 +1,7 @@
+export interface SpinnerProps {
+    size?: "sm" | "md";
+    variant?: string;
+    className?: string;
+    label?: string;
+}
+export declare function Spinner({ size, variant, className, label }: SpinnerProps): import("react").JSX.Element;

package/dist/base/Stack.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+export interface StackProps {
+    direction?: "row" | "column";
+    gap?: 0 | 1 | 2 | 3 | 4 | 5;
+    align?: "start" | "center" | "end" | "stretch" | "baseline";
+    justify?: "start" | "center" | "end" | "between" | "around" | "evenly";
+    wrap?: boolean;
+    className?: string;
+    children?: ReactNode;
+}
+/** Thin wrapper over Bootstrap's flex utilities — replaces repeated `d-flex gap-2` one-offs with one typed contract. */
+export declare function Stack({ direction, gap, align, justify, wrap, className, children }: StackProps): import("react").JSX.Element;

package/dist/base/Stepper.d.ts

@@ -0,0 +1,12 @@
+export interface StepItem {
+    key: string;
+    label: string;
+    description?: string;
+}
+export interface StepperProps {
+    steps: StepItem[];
+    /** Index of the current step (0-based). Presentation only — no built-in next/back logic, that's app-level. */
+    currentStep: number;
+    className?: string;
+}
+export declare function Stepper({ steps, currentStep, className }: StepperProps): import("react").JSX.Element;

package/dist/base/Switch.d.ts

@@ -0,0 +1,16 @@
+import { FieldIdentity, FieldState } from './shared/fieldTypes';
+export interface SwitchProps extends FieldIdentity, FieldState {
+    className?: string;
+    label?: string;
+    helpText?: string;
+    error?: string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onChange?: (checked: boolean) => void;
+}
+/**
+ * Same controlled/uncontrolled boolean behavior as CheckBox, reused via
+ * BooleanFieldControl — only the wrapper class (`form-switch`) and
+ * `role="switch"` differ (doc section 8).
+ */
+export declare function Switch(props: SwitchProps): import("react").JSX.Element;

package/dist/base/Tabs.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from 'react';
+export interface TabItem {
+    key: string;
+    label: string;
+    disabled?: boolean;
+    content: ReactNode;
+}
+export interface TabsProps {
+    items: TabItem[];
+    activeKey?: string;
+    defaultActiveKey?: string;
+    onChange?: (key: string) => void;
+    className?: string;
+}
+/** Tab definitions (`items`) are kept separate from rendering, per doc section 16. */
+export declare function Tabs({ items, activeKey, defaultActiveKey, onChange, className }: TabsProps): import("react").JSX.Element;

package/dist/base/Tag.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from 'react';
+import { BadgeVariant } from './Badge';
+export interface TagProps {
+    variant?: BadgeVariant;
+    onRemove?: () => void;
+    className?: string;
+    children: ReactNode;
+}
+/**
+ * Reuses Badge's variant type (same visual vocabulary) — the difference
+ * from Badge is purely behavioral: Tag is removable/interactive, Badge is
+ * static.
+ */
+export declare function Tag({ variant, onRemove, className, children }: TagProps): import("react").JSX.Element;

package/dist/base/TextArea.d.ts

@@ -0,0 +1,11 @@
+import { FocusEventHandler } from 'react';
+import { FieldIdentity, FieldPresentation, FieldState } from './shared/fieldTypes';
+export interface TextAreaProps extends FieldIdentity, FieldState, FieldPresentation {
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    onBlur?: FocusEventHandler<HTMLTextAreaElement>;
+    rows?: number;
+    maxLength?: number;
+}
+export declare function TextArea(props: TextAreaProps): import("react").JSX.Element;

package/dist/base/TimePicker.d.ts

@@ -0,0 +1,20 @@
+import { FieldIdentity, FieldPresentation, FieldState } from './shared/fieldTypes';
+export interface TimePickerProps extends FieldIdentity, FieldState, FieldPresentation {
+    value?: Date | null;
+    defaultValue?: Date | null;
+    onChange?: (value: Date | null) => void;
+    /** Native `<input type="time">` step, in seconds. */
+    step?: number;
+}
+/**
+ * Value strategy (doc section 12): TimePicker uses `Date`, same as
+ * DatePicker/DateTimePicker, for a coherent family — but only the
+ * hours/minutes are meaningful; the date part is normalized to the epoch so
+ * consumers can't accidentally depend on it. This is what lets
+ * DateTimePicker combine a DatePicker date-part with a TimePicker
+ * time-part into one `Date` without any string/format juggling.
+ */
+export declare function toTimeInputValue(date: Date | null | undefined): string;
+export declare function fromTimeInputValue(raw: string): Date | null;
+/** Composes Input, same pattern as DatePicker/NumberInput (doc section 19). */
+export declare function TimePicker({ value, defaultValue, onChange, step, ...rest }: TimePickerProps): import("react").JSX.Element;

package/dist/base/Toast.d.ts

@@ -0,0 +1,27 @@
+import { ReactNode } from 'react';
+import { AlertVariant } from './Alert';
+export interface ToastOptions {
+    variant?: AlertVariant;
+    /** Auto-dismiss delay in ms. Pass 0 to require manual dismissal via the Alert's close button. */
+    duration?: number;
+}
+export interface ToastApi {
+    show: (message: ReactNode, options?: ToastOptions) => number;
+    dismiss: (id: number) => void;
+    success: (message: ReactNode, options?: Omit<ToastOptions, "variant">) => number;
+    error: (message: ReactNode, options?: Omit<ToastOptions, "variant">) => number;
+    info: (message: ReactNode, options?: Omit<ToastOptions, "variant">) => number;
+    warning: (message: ReactNode, options?: Omit<ToastOptions, "variant">) => number;
+}
+/**
+ * Global toast notifications. Reuses Alert's variant styling and dismiss
+ * button (doc section 20: capability layers must not duplicate an existing
+ * implementation) for the actual message presentation — this module only
+ * owns the queue/timing/positioning concerns Alert's own doc comment
+ * deliberately left out of Alert itself.
+ */
+export declare function ToastProvider({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** Throws outside ToastProvider — same fail-fast contract as other context-backed hooks in this library. */
+export declare function useToast(): ToastApi;

package/dist/base/Tooltip.d.ts

@@ -0,0 +1,21 @@
+import { ReactNode } from 'react';
+export interface TooltipProps {
+    content: ReactNode;
+    children: ReactNode;
+    placement?: "top" | "bottom";
+    className?: string;
+}
+/**
+ * Reuses the existing Popup primitive (open/close, escape-to-close, outside
+ * click, cleanup — all already implemented and tested) with Bootstrap's
+ * real tooltip CSS classes for visual fidelity.
+ *
+ * Deliberately NOT wired to Bootstrap's own JS Tooltip plugin: that plugin
+ * needs `@popperjs/core` (the plain `bootstrap` package doesn't bundle it —
+ * only its non-ESM `bootstrap.bundle.js` does), so wiring it up would mean
+ * either adding a new dependency or a fragile UMD-inside-an-ESM-library
+ * dynamic import. Reusing our own already-tested Popup is the more
+ * conservative choice here, not less (doc section 18: "do NOT introduce
+ * another positioning library unless actually necessary").
+ */
+export declare function Tooltip({ content, children, placement, className }: TooltipProps): import("react").JSX.Element;

package/dist/base/index.d.ts

@@ -0,0 +1,56 @@
+export * from './Input';
+export * from './TextArea';
+export * from './NumberInput';
+export * from './PasswordInput';
+export * from './FileInput';
+export * from './CheckBox';
+export * from './Switch';
+export * from './RadioButton';
+export * from './RadioGroup';
+export * from './Select';
+export * from './MultiSelect';
+export * from './DatePicker';
+export * from './TimePicker';
+export * from './DateTimePicker';
+export * from './ComboBox';
+export * from './AutoComplete';
+export * from './FormField';
+export * from './Modal';
+export * from './DataGrid';
+export * from './Pagination';
+export * from './Button';
+export * from './Spinner';
+export * from './Alert';
+export * from './Toast';
+export * from './Confirm';
+export * from './Badge';
+export * from './Tabs';
+export * from './Accordion';
+export * from './Tooltip';
+export * from './Popover';
+export * from './Card';
+export * from './Divider';
+export * from './Stack';
+export * from './Container';
+export * from './Row';
+export * from './Col';
+export * from './Breadcrumb';
+export * from './Menu';
+export * from './Stepper';
+export * from './Avatar';
+export * from './Tag';
+export * from './Skeleton';
+export * from './Slider';
+export * from './Rating';
+export * from './ProgressBar';
+export * from './Icon';
+export * from './Navbar';
+export * from './Sidebar';
+export * from './PageHeader';
+export { Popup } from './shared/Popup';
+export type { PopupProps } from './shared/Popup';
+export { Label } from './shared/Label';
+export type { LabelProps } from './shared/Label';
+export { ValidationMessage } from './shared/ValidationMessage';
+export type { ValidationMessageProps } from './shared/ValidationMessage';
+export type { FieldIdentity, FieldPresentation, FieldState, SelectOption } from './shared/fieldTypes';

package/dist/base/shared/BooleanFieldControl.d.ts

@@ -0,0 +1,22 @@
+import { FieldIdentity } from './fieldTypes';
+export interface BooleanFieldControlProps extends FieldIdentity {
+    disabled?: boolean;
+    required?: boolean;
+    className?: string;
+    wrapperClassName: string;
+    role?: string;
+    label?: string;
+    helpText?: string;
+    error?: string;
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+}
+/**
+ * Internal-only shared rendering for CheckBox and Switch: their public APIs
+ * are genuinely identical (checked/defaultChecked/onChange/label/error/
+ * helpText) and their markup differs only by wrapper class + `role` (doc
+ * section 8: "reuse if semantically correct, but don't couple them through
+ * an abstraction that makes either public API worse" — this doesn't, since
+ * both components keep their own separate, unchanged public props).
+ */
+export declare function BooleanFieldControl({ id, name, disabled, required, wrapperClassName, role, label, helpText, error, checked, onChange, className, }: BooleanFieldControlProps): import("react").JSX.Element;

package/dist/base/shared/FieldShell.d.ts

@@ -0,0 +1,22 @@
+import { ReactNode } from 'react';
+export interface FieldShellProps {
+    id?: string;
+    label?: string;
+    required?: boolean;
+    error?: string;
+    helpText?: string;
+    className?: string;
+    children: ReactNode;
+}
+/**
+ * Shared label / help-text / validation-message presentation wrapper reused
+ * by every Base field that has that shape (Input, TextArea, NumberInput,
+ * DatePicker, TimePicker, ComboBox, AutoComplete, Select, MultiSelect,
+ * RadioGroup, DateTimePicker). CheckBox/Switch and DataGrid have a
+ * genuinely different layout and intentionally don't use this (they reuse
+ * ValidationMessage directly instead — see BooleanFieldControl).
+ *
+ * Bootstrap conventions (`form-label`, `invalid-feedback`, `form-text`) are
+ * used directly rather than reinventing a styling layer (doc section 15).
+ */
+export declare function FieldShell({ id, label, required, error, helpText, className, children }: FieldShellProps): import("react").JSX.Element;

package/dist/base/shared/Label.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from 'react';
+export interface LabelProps {
+    htmlFor?: string;
+    required?: boolean;
+    className?: string;
+    children: ReactNode;
+}
+/** Extracted out of FieldShell so it's independently usable (doc "Form Infrastructure" section). */
+export declare function Label({ htmlFor, required, className, children }: LabelProps): import("react").JSX.Element;

package/dist/base/shared/Popup.d.ts

@@ -0,0 +1,25 @@
+import { ReactNode, RefObject } from 'react';
+export interface PopupProps {
+    open: boolean;
+    onClose: () => void;
+    anchorRef: RefObject<HTMLElement>;
+    className?: string;
+    /** ARIA role of the floating panel — callers set this (e.g. "listbox" for ComboBox, none for Tooltip/Popover). */
+    role?: string;
+    children: ReactNode;
+}
+/**
+ * Anchored floating panel: open/close, escape-to-close, outside-click
+ * dismissal, cleanup. Reused by ComboBox/AutoComplete/MultiSelect (as a
+ * dropdown listbox) and by Tooltip/Popover (as a hover/click overlay) — so
+ * it only forces Bootstrap's universal `show` visibility class; the
+ * dropdown-specific (`dropdown-menu`) vs. tooltip/popover-specific
+ * (`tooltip`, `popover`) presentation classes are each caller's own
+ * responsibility via `className`.
+ *
+ * Known limitation (documented, not silently ignored): positioning is plain
+ * CSS (`position: relative` on the anchor's wrapper), no portal/collision
+ * detection yet. A portal-based strategy can be layered in later without
+ * changing this component's public API.
+ */
+export declare function Popup({ open, onClose, anchorRef, className, role, children }: PopupProps): import("react").JSX.Element | null;

package/dist/base/shared/ValidationMessage.d.ts

@@ -0,0 +1,11 @@
+export interface ValidationMessageProps {
+    error?: string;
+    helpText?: string;
+    className?: string;
+}
+/**
+ * Presentation only — owns no validation rules (doc section 10). Extracted
+ * out of FieldShell so CheckBox/Switch (which don't use FieldShell's
+ * `form-label` layout) can still reuse the identical error/help rendering.
+ */
+export declare function ValidationMessage({ error, helpText, className }: ValidationMessageProps): import("react").JSX.Element | null;

package/dist/base/shared/classNames.d.ts

@@ -0,0 +1 @@
+export declare function cx(...values: Array<string | false | null | undefined>): string;

package/dist/base/shared/fieldTypes.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Small, semantic prop contracts shared only where a genuine relationship
+ * exists between fields. Deliberately NOT a single "MassiveUniversalComponentProps"
+ * — components compose the subset that applies to them (see doc section 13).
+ */
+export interface FieldIdentity {
+    id?: string;
+    name?: string;
+}
+export interface FieldState {
+    disabled?: boolean;
+    readOnly?: boolean;
+    required?: boolean;
+}
+export interface FieldPresentation {
+    className?: string;
+    label?: string;
+    placeholder?: string;
+    helpText?: string;
+    error?: string;
+}
+export interface SelectOption<TValue = string | number> {
+    value: TValue;
+    label: string;
+    disabled?: boolean;
+}

package/dist/base/shared/index.d.ts

@@ -0,0 +1,9 @@
+export * from './classNames';
+export * from './fieldTypes';
+export * from './useControllableState';
+export * from './useEscapeKey';
+export * from './useListNavigation';
+export * from './Label';
+export * from './ValidationMessage';
+export * from './FieldShell';
+export * from './Popup';

package/dist/base/shared/useControllableState.d.ts

@@ -0,0 +1,16 @@
+export interface ControllableStateOptions<T> {
+    /** When defined, the component is controlled: this value always wins. */
+    value?: T;
+    defaultValue: T;
+    onChange?: (value: T) => void;
+}
+/**
+ * Single shared implementation of the library's controlled/uncontrolled policy
+ * (doc section 14). Every Base form field composes this instead of
+ * reimplementing its own controlled/uncontrolled logic.
+ *
+ * Policy: presence of `value !== undefined` on first render decides the mode
+ * for the component's lifetime. Switching modes afterwards is a programmer
+ * error and is flagged in development, mirroring React's own <input> warning.
+ */
+export declare function useControllableState<T>({ value, defaultValue, onChange, }: ControllableStateOptions<T>): [T, (next: T) => void];

package/dist/base/shared/useEscapeKey.d.ts

@@ -0,0 +1,2 @@
+/** Shared by Popup and Modal so escape-to-close isn't reimplemented per component. */
+export declare function useEscapeKey(active: boolean, onEscape: () => void): void;

package/dist/base/shared/useListNavigation.d.ts

@@ -0,0 +1,18 @@
+import { KeyboardEvent } from 'react';
+export interface UseListNavigationOptions {
+    itemCount: number;
+    isOpen: boolean;
+    onSelect: (index: number) => void;
+    onClose: () => void;
+}
+export interface UseListNavigationResult {
+    activeIndex: number;
+    setActiveIndex: (index: number) => void;
+    handleKeyDown: (event: KeyboardEvent) => void;
+}
+/**
+ * Headless keyboard-navigation behavior shared by ComboBox and AutoComplete
+ * (doc section 19 — "shared behavior" reuse for the list-selection concern
+ * that both components genuinely have in common).
+ */
+export declare function useListNavigation({ itemCount, isOpen, onSelect, onClose, }: UseListNavigationOptions): UseListNavigationResult;