@ufoui/core 0.0.1

package/components/menuItem/menuItem.d.ts

@@ -0,0 +1,179 @@
+import { default as React, HTMLProps, ReactNode } from 'react';
+import { ElementDensity, ElementFocusEffect, ElementFont, ElementSelectedEffect, ElementShape, ElementTouchEffect } from '../utils';
+import { MenuVariant } from '../menu/menu';
+import { SurfaceColor } from '../../utils/color';
+/**
+ * Visual variant of a MenuItem.
+ *
+ * Inherited from {@link MenuVariant}.
+ *
+ * @category MenuItem
+ */
+export type MenuItemVariant = MenuVariant;
+/**
+ * Defines the behavioral type of a MenuItem.
+ *
+ * - `item` – simple action item
+ * - `checkbox` – toggleable multiple-selection item
+ * - `radio` – mutually exclusive selection item
+ * - `option` – selectable option item
+ *
+ * @category MenuItem
+ */
+export type MenuItemType = 'item' | 'checkbox' | 'radio' | 'option';
+/**
+ * Change event payload for selectable menu items
+ * (checkbox, radio and option).
+ *
+ * @category MenuItem
+ */
+export interface MenuItemChangeEvent {
+    /** Checkbox or radio checked state. */
+    checked?: boolean;
+    /** Item name identifier. */
+    name?: string;
+    /** Selection state for option items. */
+    selected?: boolean;
+    /** Item value identifier. */
+    value?: string;
+}
+/**
+ * Props for the {@link MenuItem} component.
+ *
+ * @category MenuItem
+ */
+export interface MenuItemProps extends Omit<HTMLProps<HTMLDivElement>, 'ref' | 'onChange'> {
+    /** Marks item as active (roving focus). */
+    active?: boolean;
+    /** Badge content rendered at the end. */
+    badge?: ReactNode;
+    /** Checked state for checkbox or radio items. */
+    checked?: boolean;
+    /** Icon shown when item is checked. */
+    checkedIcon?: ReactNode;
+    /** Item content or nested submenu. */
+    children?: ReactNode;
+    /** Base surface color of the item. */
+    color?: SurfaceColor;
+    /** Density preset controlling spacing. */
+    density?: ElementDensity;
+    /** Secondary description text. */
+    description?: string;
+    /** Text color of the description. */
+    descriptionColor?: SurfaceColor;
+    /** Font token applied to the description text. */
+    descriptionFont?: ElementFont;
+    /** Disables interactions and focus. */
+    disabled?: boolean;
+    /** Icon rendered at the end (alias for `trailing`). */
+    endIcon?: ReactNode;
+    /** Whether a nested submenu is expanded. */
+    expanded?: boolean;
+    /** Reserves leading slot even without an icon. */
+    fixedLeading?: boolean;
+    /** Visual focus effects applied when active. */
+    focusEffects?: ElementFocusEffect[];
+    /** Forces focus-visible styling. */
+    focusVisible?: boolean;
+    /** Alias for labelFont. */
+    font?: ElementFont;
+    /** Enables horizontal layout mode. */
+    horizontal?: boolean;
+    /** Icon rendered at the start (alias for `leading`). */
+    icon?: ReactNode;
+    /** Primary label text. */
+    label?: string;
+    /** Text color of the label. */
+    labelColor?: SurfaceColor;
+    /** Font token applied to the label text. */
+    labelFont?: ElementFont;
+    /** Custom leading content. */
+    leading?: ReactNode;
+    /** Item name used in change events. */
+    name?: string;
+    /** Change handler for checkbox, radio and option items. */
+    onChange?: (e: MenuItemChangeEvent) => void;
+    /** Click handler for action items. */
+    onClick?: React.MouseEventHandler<HTMLDivElement>;
+    /** Selected state for option items. */
+    selected?: boolean;
+    /** Background color used when selected. */
+    selectedColor?: SurfaceColor;
+    /** Visual effects applied when selected. */
+    selectedEffects?: ElementSelectedEffect[];
+    /** Shape token applied to the item. */
+    shape?: ElementShape;
+    /** Keyboard shortcut label. */
+    shortcut?: string;
+    /** Text color of the shortcut label. */
+    shortcutColor?: SurfaceColor;
+    /** Font token applied to the shortcut text. */
+    shortcutFont?: ElementFont;
+    /** Overrides automatic text color. */
+    textColor?: SurfaceColor;
+    /** Touch and click feedback effects. */
+    touchEffects?: ElementTouchEffect[];
+    /** Custom trailing content. */
+    trailing?: ReactNode;
+    /** Item behavior type. */
+    type?: MenuItemType;
+    /** Icon shown when item is unchecked. */
+    uncheckedIcon?: ReactNode;
+    /** Item value used in change events. */
+    value?: string;
+    /** Visual variant inherited from Menu. */
+    variant?: MenuItemVariant;
+}
+/**
+ * Internal props injected by Menu.
+ *
+ * @internal
+ * @category MenuItem
+ */
+export interface MenuItemInternalProps {
+    /** Disables pointer and keyboard interactions. */
+    __interactionsDisabled?: boolean;
+    /** Item index inside the parent menu. */
+    __index?: number;
+    /** Index exposed for DOM queries. */
+    'data-menu-index'?: number;
+    /** ARIA role family inherited from parent container. */
+    roleFamily?: 'menu' | 'listbox' | 'command' | 'toolbar';
+}
+/**
+ * **MenuItem** - single interactive item inside a {@link Menu}.
+ *
+ * Represents an action, checkbox, radio item or selectable option.
+ * Supports icons, badges, shortcuts, descriptions and nested submenus.
+ *
+ * Keyboard interaction and focus are handled by the parent Menu.
+ *
+ * @param props
+ *
+ * @example
+ * ```tsx
+ * <MenuItem label="Open" onClick={handleOpen} />
+ * ```
+ *
+ * @example
+ * ```tsx
+ * <MenuItem
+ *   type="checkbox"
+ *   label="Show grid"
+ *   checked={enabled}
+ *   onChange={() => setEnabled(v => !v)}
+ * />
+ * ```
+ *
+ * @example
+ * ```tsx
+ * <MenuItem label="More">
+ *   <Menu>
+ *     <MenuItem label="Sub item" />
+ *   </Menu>
+ * </MenuItem>
+ * ```
+ * @function
+ * @category MenuItem
+ */
+export declare const MenuItem: React.ForwardRefExoticComponent<MenuItemProps & MenuItemInternalProps & React.RefAttributes<HTMLDivElement>>;

package/components/menuItem/menuItem.guards.d.ts

@@ -0,0 +1,15 @@
+import { default as React, ReactElement } from 'react';
+import { MenuItemInternalProps, MenuItemProps } from './menuItem';
+export declare const IS_MENU_ITEM: unique symbol;
+/**
+ * Type guard that checks whether a React node is a MenuItem component.
+ *
+ * Identifies MenuItem elements by the internal {@link IS_MENU_ITEM} symbol
+ * attached to the component type.
+ *
+ * @param el - React node to test.
+ * @returns `true` if the node is a MenuItem element.
+ *
+ * @internal
+ */
+export declare function isMenuItem(el: React.ReactNode): el is ReactElement<MenuItemProps & MenuItemInternalProps>;

package/components/nav/nav.d.ts

@@ -0,0 +1,27 @@
+import { BoxBaseProps } from '../core';
+/**
+ * Props for {@link Nav}.
+ * Extends {@link BoxBaseProps} except for `elementClass` and `component`.
+ *
+ * @category Box
+ */
+export type NavProps = Omit<BoxBaseProps, 'elementClass' | 'component'>;
+/**
+ * Semantic layout wrapper for the native `<nav>` element.
+ *
+ * Built on top of {@link BoxBase}, inheriting its layout and styling props.
+ * Defaults to a row layout (`direction="row"`) and applies
+ * the semantic UUI class `"uui-nav"`.
+ *
+ * Use for primary or secondary navigation menus.
+ *
+ * @function
+ * @param props - All layout and style props inherited from {@link BoxBase}.
+ * @example
+ * <Nav elevation={1} shape="rounded">
+ *   <NavLink href="/">Home</NavLink>
+ * </Nav>
+ *
+ * @category Box
+ */
+export declare const Nav: import('react').ForwardRefExoticComponent<NavProps & import('react').RefAttributes<HTMLElement>>;

package/components/numberInput/numberInput.d.ts

@@ -0,0 +1,2 @@
+import { FieldBaseProps } from '../base/fieldBase/fieldBase';
+export declare const NumberInput: import('react').ForwardRefExoticComponent<FieldBaseProps & import('react').RefAttributes<HTMLInputElement>>;

package/components/option/option.d.ts

@@ -0,0 +1,6 @@
+import { ForwardRefExoticComponent, RefAttributes } from 'react';
+import { MenuItemInternalProps, MenuItemProps } from '../core';
+export interface OptionProps extends Omit<MenuItemProps, 'type' | 'checked'> {
+    selected?: boolean;
+}
+export declare const Option: ForwardRefExoticComponent<OptionProps & MenuItemInternalProps & RefAttributes<HTMLDivElement>>;

package/components/option/option.guards.d.ts

@@ -0,0 +1,16 @@
+import { default as React, ReactElement } from 'react';
+import { OptionProps } from './option';
+import { MenuItemInternalProps } from '../menuItem/menuItem';
+export declare const IS_OPTION: unique symbol;
+/**
+ * Type guard that checks whether a React node is an Option component.
+ *
+ * Identifies Option elements by the internal {@link IS_OPTION} symbol
+ * attached to the component type.
+ *
+ * @param el - React node to test.
+ * @returns `true` if the node is an Option element.
+ *
+ * @internal
+ */
+export declare function isOption(el: React.ReactNode): el is ReactElement<OptionProps & MenuItemInternalProps>;

package/components/radio/radio.d.ts

@@ -0,0 +1,31 @@
+import { CheckboxBaseProps } from '../core';
+/**
+ * Props for the Radio component.
+ *
+ * Extends {@link CheckboxBaseProps} with radio-specific defaults
+ * and removes indeterminate-related options.
+ *
+ * @category Radio
+ */
+export type RadioProps = Omit<CheckboxBaseProps, 'type' | 'elementClass' | 'indeterminateIcon' | 'indeterminate'>;
+/**
+ * Radio button component built on top of {@link CheckboxBase}.
+ *
+ * Provides radio-specific defaults, circular shape,
+ * and checked icon rendering.
+ *
+ * @param props Component properties.
+ * @function
+ *
+ * @example
+ * <Radio label="Option A" />
+ *
+ * @example
+ * <Radio
+ *   label="Option B"
+ *   checked
+ * />
+ *
+ * @category Radio
+ */
+export declare const Radio: import('react').ForwardRefExoticComponent<RadioProps & import('react').RefAttributes<HTMLInputElement>>;

package/components/radiogroup/radioGroup.d.ts

@@ -0,0 +1,47 @@
+import { default as React, ReactNode } from 'react';
+import { FieldsetProps } from '../fieldset/fieldset';
+/**
+ * Props for the RadioGroup component.
+ *
+ * @category RadioGroup
+ */
+export interface RadioGroupProps extends Omit<FieldsetProps, 'component' | 'elementClass' | 'defaultChecked' | 'onChange'> {
+    /** Shared name attribute for all radio buttons in the group. */
+    name: string;
+    /** Initial selected value for uncontrolled usage. */
+    defaultValue?: string;
+    /** Controlled selected value. */
+    value?: string;
+    /** Called when the selected value changes. */
+    onChange?: (value: string) => void;
+    /** Radio buttons rendered inside the group. */
+    children: ReactNode;
+}
+/**
+ * Groups related radio buttons into a single selectable set.
+ *
+ * Supports controlled and uncontrolled usage.
+ *
+ * @category RadioGroup
+ * @function
+ * @param props RadioGroupProps
+ *
+ *
+ * @example
+ * // Uncontrolled
+ * <RadioGroup name="options" defaultValue="a">
+ *   <Radio value="a" label="Option A" />
+ *   <Radio value="b" label="Option B" />
+ * </RadioGroup>
+ *
+ *
+ * @example
+ * // Controlled
+ * const [value, setValue] = useState('a');
+ *
+ * <RadioGroup name="options" value={value} onChange={setValue}>
+ *   <Radio value="a" label="Option A" />
+ *   <Radio value="b" label="Option B" />
+ * </RadioGroup>
+ */
+export declare const RadioGroup: React.ForwardRefExoticComponent<RadioGroupProps & React.RefAttributes<HTMLFieldSetElement>>;

package/components/section/section.d.ts

@@ -0,0 +1,27 @@
+import { BoxBaseProps } from '../core';
+/**
+ * Props for {@link Section}.
+ * Extends {@link BoxBaseProps} except for `elementClass` and `component`.
+ *
+ * @category Box
+ */
+export type SectionProps = Omit<BoxBaseProps, 'elementClass' | 'component'>;
+/**
+ * Semantic layout wrapper for the native `<section>` element.
+ *
+ * Built on top of {@link BoxBase}, inheriting its layout and styling props.
+ * Defaults to a column layout (`direction="col"`) and applies
+ * the semantic UUI class `"uui-section"`.
+ *
+ * Use for grouping related content within a document or page.
+ *
+ * @function
+ * @param props - All layout and style props inherited from {@link BoxBase}.
+ * @example
+ * <Section elevation={1} shape="rounded">
+ *   <Article />
+ * </Section>
+ *
+ * @category Box
+ */
+export declare const Section: import('react').ForwardRefExoticComponent<SectionProps & import('react').RefAttributes<HTMLElement>>;

package/components/select/select.d.ts

@@ -0,0 +1,32 @@
+import { ReactNode } from 'react';
+import { FieldBaseProps } from '../core';
+/**
+ * Props for {@link Select}.
+ *
+ * @category Field
+ */
+export interface SelectProps extends Omit<FieldBaseProps, 'elementClass' | 'value' | 'onChange'> {
+    /** Current selected value. */
+    value?: string | string[];
+    /** Placeholder displayed when no value is selected. */
+    placeholder?: string;
+    /** Change handler called with the selected value. */
+    onChange?: (value: string | string[] | undefined) => void;
+    /** Enables multiple value selection. */
+    multiple?: boolean;
+    /** Makes the control read-only. */
+    readOnly?: boolean;
+    /** Custom renderer for the selected value. */
+    renderValue?: (value: string | string[] | undefined) => ReactNode;
+    /** Select options. */
+    children?: ReactNode;
+}
+/**
+ * **Select** – form control used to choose one or multiple values
+ * from a predefined list of options.
+ *
+ * @param props
+ *
+ * @category Field
+ * @function
+ */

package/components/spinner/spinner.d.ts

@@ -0,0 +1,7 @@
+export type SpinnerVariant = 'circular' | 'dots' | 'bars' | 'ring' | 'bars2' | 'orbit' | 'arc' | 'stepBar';
+export interface SpinnerProps {
+    variant?: SpinnerVariant;
+    className?: string;
+    inline?: boolean;
+}
+export declare function Spinner({ variant, inline, className }: SpinnerProps): import("react/jsx-runtime").JSX.Element;

package/components/switch/switch.d.ts

@@ -0,0 +1,102 @@
+import { default as React, ReactNode } from 'react';
+import { ElementAlign, ElementDensity, ElementElevation, ElementFocusEffect, ElementFont, ElementHoverEffect, ElementOutline, ElementPressedEffect, ElementSelectedEffect, ElementShape, ElementSize, ElementTextPlacement, ElementTouchEffect } from '../utils';
+import { BorderColor, SemanticColor, SurfaceColor } from '../../utils/color';
+/**
+ * Props for the Switch component.
+ *
+ * Low-level boolean control.
+ *
+ * @category Switch
+ */
+export interface SwitchProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'color' | 'size' | 'type'> {
+    /** Border style when outlined. */
+    border?: ElementOutline;
+    /** Border color override. */
+    borderColor?: BorderColor;
+    /** Border color when unchecked. */
+    uncheckedBorderColor?: BorderColor;
+    /** Custom content rendered inside the control. */
+    children?: ReactNode;
+    /** Additional root class name. */
+    className?: string;
+    /** Semantic color used for the checked state. */
+    color?: SemanticColor;
+    /** Semantic color used for the unchecked state. */
+    uncheckedColor?: SemanticColor;
+    /** Visual density affecting layout spacing. */
+    density?: ElementDensity;
+    /** Supporting text displayed below the label. */
+    description?: string;
+    /** Text color override for the description. */
+    descriptionColor?: SurfaceColor;
+    /** Font token applied to the description text. */
+    descriptionFont?: ElementFont;
+    /** Elevation level of the control surface. */
+    elevation?: ElementElevation;
+    /** Error message text. Overrides description when present. */
+    error?: string;
+    /** Focus ring color override. */
+    focusColor?: BorderColor;
+    /** Visual effects applied on focus. */
+    focusEffects?: ElementFocusEffect[];
+    /** Font token applied to the label text. */
+    font?: ElementFont;
+    /** Enables full color rendering for the unchecked state. */
+    fullColor?: boolean;
+    /** Visual effects applied on hover. */
+    hoverEffects?: ElementHoverEffect[];
+    /** Icon rendered when checked. */
+    icon?: ReactNode;
+    /** DOM id. Auto-generated if not provided. */
+    id?: string;
+    /** Text label associated with the control. */
+    label?: string;
+    /** Text color override for the label. */
+    labelColor?: SurfaceColor;
+    /** Name attribute forwarded to the input element. */
+    name?: string;
+    /** Change event handler. */
+    onChange?: React.ChangeEventHandler<HTMLInputElement>;
+    /** Visual effects applied on press. */
+    pressedEffects?: ElementPressedEffect[];
+    /** Marks the control as required. Visual only. */
+    required?: boolean;
+    /** Visual effects applied when checked. */
+    selectedEffects?: ElementSelectedEffect[];
+    /** Shape variant of the control. */
+    shape?: ElementShape;
+    /** Size of the control. */
+    size?: ElementSize;
+    /** Text color override for label and content. */
+    textColor?: SurfaceColor;
+    /** Layout of text relative to the control. */
+    textPlacement?: ElementTextPlacement;
+    /** Tooltip alignment relative to the control. */
+    tooltipAlign?: ElementAlign;
+    /** Touch and click visual effects. */
+    touchEffects?: ElementTouchEffect[];
+    /** Border style when unchecked. */
+    uncheckedBorder?: ElementOutline;
+    /** Icon rendered when unchecked. */
+    uncheckedIcon?: ReactNode;
+    /** Controlled value forwarded to the input element. */
+    value?: string;
+    /** Duration of the thumb transition between checked and unchecked states. */
+    duration?: number;
+    /** Marks the control as read-only. Applies aria-readonly. */
+    readOnly?: boolean;
+}
+/**
+ * Switch control used to toggle a setting on or off.
+ *
+ * Represents an immediate boolean preference.
+ *
+ * @function Switch
+ * @param props Component properties.
+ *
+ * @example
+ * <Switch label="Notifications" />
+ *
+ * @category Switch
+ */
+export declare const Switch: React.ForwardRefExoticComponent<SwitchProps & React.RefAttributes<HTMLInputElement>>;

package/components/telInput/telInput.d.ts

@@ -0,0 +1,2 @@
+import { FieldBaseProps } from '../base/fieldBase/fieldBase';
+export declare const TelInput: import('react').ForwardRefExoticComponent<FieldBaseProps & import('react').RefAttributes<HTMLInputElement>>;

package/components/textField/textField.d.ts

@@ -0,0 +1,9 @@
+import { FieldBaseProps } from '../core';
+/**
+ * Props for {@link TextField}.
+ * Extends {@link FieldBaseProps}.
+ *
+ * @category Field
+ */
+export type FieldProps = Omit<FieldBaseProps, 'elementClass'>;
+export declare const TextField: import('react').ForwardRefExoticComponent<FieldProps & import('react').RefAttributes<HTMLInputElement>>;

package/components/themeProvider/themeProvider.d.ts

@@ -0,0 +1,54 @@
+import { ReactNode } from 'react';
+export interface ThemeProviderProps {
+    /** React children to render within the theme context. */
+    children: ReactNode;
+    /**
+     * Optional color mode: 'light' or 'dark'.
+     * If not provided, defaults to 'light'.
+     */
+    colorMode?: 'light' | 'dark';
+    /**
+     * Optional seed color used to generate MD3 theme.
+     * Defaults to #6750A4 if omitted.
+     */
+    seedColor?: string;
+    /**
+     * Optional custom colors used for info, warning, and success roles.
+     * If omitted, defaults to:
+     * - info: #03a9f4
+     * - warning: #ffd600
+     * - success: #689f38
+     */
+    extraColors?: Partial<Record<'info' | 'warning' | 'success', string>>;
+}
+/**
+ * Provides a ThemeContext to all descendant components using Material Design 3 color tokens.
+ *
+ * - Dynamically generates full theme schemes (`light` and `dark`) based on the provided `seedColor`
+ *   and optional `extraColors` (`info`, `warning`, `success`).
+ * - Injects resolved colors as CSS custom properties into the DOM (`:root` and `.dark`).
+ * - Automatically toggles the `.dark` class on `<body>` based on `colorMode`.
+ * - Exposes utility functions via context:
+ *   - `setTheme`: updates the full theme object
+ *   - `setDarkMode`: enables/disables dark mode
+ *   - `getColorValue`: gets current color value (light or dark based on mode)
+ *   - `getThemeColorValue`: gets any color from a specified scheme (`light` or `dark`)
+ *
+ * This provider must wrap your application to enable theming and contextual access to color tokens.
+ *
+ * @param children - React children rendered within the theme context.
+ * @param colorMode - Optional color mode: `'light'` or `'dark'`. Defaults to `'light'`.
+ * @param seedColor - Optional base color used to generate the theme. Defaults to `#6750A4`.
+ * @param extraColors - Optional custom base colors for semantic roles (`info`, `warning`, `success`).
+ *
+ * @example
+ * ```tsx
+ * <ThemeProvider colorMode="dark" seedColor="#6200ee" extraColors={{ info: '#2196f3' }}>
+ *   <App />
+ * </ThemeProvider>
+ * ```
+ *
+ * @category Components
+ * @group Theme
+ */
+export declare const ThemeProvider: ({ children, colorMode, seedColor, extraColors }: ThemeProviderProps) => import("react/jsx-runtime").JSX.Element;

package/components/timeInput/timeInput.d.ts

@@ -0,0 +1,2 @@
+import { FieldBaseProps } from '../base/fieldBase/fieldBase';
+export declare const TimeInput: import('react').ForwardRefExoticComponent<FieldBaseProps & import('react').RefAttributes<HTMLInputElement>>;

package/components/toggleButton/toggleButton.d.ts

@@ -0,0 +1,6 @@
+import { ButtonBaseProps } from '../core';
+export interface ToggleButtonProps extends Omit<ButtonBaseProps, 'filled' | 'controlClass' | 'iconClass'> {
+    selected?: boolean;
+    iconPosition?: 'start' | 'end';
+}
+export declare const ToggleButton: import('react').ForwardRefExoticComponent<ToggleButtonProps & import('react').RefAttributes<HTMLButtonElement>>;

package/components/tooltip/tooltip.d.ts

@@ -0,0 +1,8 @@
+import { HTMLProps, ReactNode } from 'react';
+import { ElementAlign } from '../utils';
+export interface TooltipProps extends HTMLProps<HTMLDivElement> {
+    title: string;
+    children?: ReactNode;
+    align?: ElementAlign;
+}
+export declare const Tooltip: import('react').ForwardRefExoticComponent<Omit<TooltipProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;

package/components/urlInput/urlInput.d.ts

@@ -0,0 +1,2 @@
+import { FieldBaseProps } from '../base/fieldBase/fieldBase';
+export declare const UrlInput: import('react').ForwardRefExoticComponent<FieldBaseProps & import('react').RefAttributes<HTMLInputElement>>;

package/context/fieldsetContext.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Context value shared by {@link Fieldset} and its child controls.
+ *
+ * Provides semantic state for grouped form elements.
+ *
+ * @category Contexts
+ */
+export interface FieldsetContextValue {
+    /** Whether all controls inside the fieldset should be disabled. */
+    disabled?: boolean;
+}
+/**
+ * FieldsetContext provides access to the current fieldset state.
+ *
+ * Used by form controls (e.g. Checkbox, Radio) to inherit
+ * group-level properties such as `disabled`.
+ *
+ * Returns `null` if used outside a {@link Fieldset}.
+ *
+ * @category Contexts
+ */
+export declare const FieldsetContext: import('react').Context<FieldsetContextValue | null>;

package/context/radioGroupContext.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Context value shared by {@link RadioGroup} and radio controls.
+ *
+ * Provides group-level state and behavior for radio button collections.
+ *
+ * @category Contexts
+ */
+export interface RadioGroupContextValue {
+    /** Whether all radio controls inside the group are disabled. */
+    disabled?: boolean;
+    /** Shared name attribute applied to all radio inputs in the group. */
+    name: string;
+    /** Updates the selected value of the radio group. */
+    setValue?: (v: string) => void;
+    /** Currently selected value of the radio group. */
+    value?: string;
+}
+/**
+ * RadioGroupContext provides access to the current radio group state.
+ *
+ * Used by radio controls to inherit group-level properties such as
+ * `name`, `value`, `disabled`, and selection behavior.
+ *
+ * Returns `null` if used outside a {@link RadioGroup}.
+ *
+ * @category Contexts
+ */
+export declare const RadioGroupContext: import('react').Context<RadioGroupContextValue | null>;