@arun-dev/headless 4.14.0 → 4.16.0

package/dist/menu/index.d.cts

@@ -2,6 +2,11 @@ import * as react from 'react';
 import { ReactNode, ReactElement, Ref, ComponentPropsWithRef } from 'react';
 import { A as AnchorSide, a as AnchorAlign } from '../anchoring-Btxi0QwC.cjs';
 
+/** The state Menu.Root shares with its parts, and projects as `data-*` attributes. */
+type MenuState = {
+    open: boolean;
+};
+
 type MenuRootProps = {
     /**
      * Controlled state. Provide `onOpenChange` alongside it.
@@ -34,7 +39,7 @@ type MenuRootProps = {
  * Each Item registers its own `disabled` from its props; the Root never reads it back from
  * the DOM (decision 10). Elements are kept only to move focus to.
  */
-declare function MenuRoot({ open: openProp, defaultOpen, onOpenChange, focusableWhenDisabled, children, }: MenuRootProps): react.JSX.Element;
+declare function MenuRoot({ children, ...props }: MenuRootProps): react.JSX.Element;
 
 type MenuTriggerOwnProps = {
     /** Element to render instead of the default `<button>`. Props and ref are merged onto it. */
@@ -53,7 +58,10 @@ declare function MenuTrigger({ className, children, render, ...rest }: MenuTrigg
 type MenuSide = AnchorSide;
 type MenuAlign = AnchorAlign;
 type MenuPopupOwnProps = {
-    /** Which side of the trigger to open on. Flips to the opposite side when there is no room. */
+    /**
+     * Which side of the trigger to open on. Flips to the opposite side when there is no room.
+     * Defaults to `'bottom'`, and to `'right'` in a submenu.
+     */
     side?: MenuSide;
     /** Where along that side: flush with the trigger's start or end edge, or centred on it. */
     align?: MenuAlign;
@@ -68,14 +76,19 @@ type MenuPopupProps = MenuPopupOwnProps & Omit<ComponentPropsWithRef<'div'>, key
  * Popover's popup is (decision 12), and labelled by it.
  *
  * Opening moves focus to the first item — the last, when Up on the Trigger opened it. Up
- * and Down then move between items, wrapping, with Home and End; disabled items are skipped
- * unless the Root sets `focusableWhenDisabled`. Tab closes the menu and lets focus move on.
+ * and Down then move between items, wrapping, with Home and End; typing moves to the next item
+ * whose text starts with what was typed. Disabled items are skipped by both, unless the Root
+ * sets `focusableWhenDisabled`. Tab closes the menu and lets focus move on.
+ *
+ * Inside a SubmenuRoot it is that submenu's popup: it opens beside its SubmenuTrigger, ← (→ in
+ * a right-to-left menu) closes it, and Tab closes every level. Closing with focus inside returns
+ * it to the SubmenuTrigger.
  *
  * Light dismiss and Esc close the element before anyone is asked; the `toggle` event
  * reports it through the Root, and the element reopens if the state stays open. Focus
  * returns to the Trigger, the invoker, whenever the menu hides with focus inside it.
  */
-declare function MenuPopup({ side, align, className, children, render, ...rest }: MenuPopupProps): ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+declare function MenuPopup({ side: sideProp, align, className, children, render, ...rest }: MenuPopupProps): ReactElement<unknown, string | react.JSXElementConstructor<any>>;
 
 type MenuItemOwnProps = {
     /**
@@ -83,6 +96,11 @@ type MenuItemOwnProps = {
      * `focusableWhenDisabled`.
      */
     disabled?: boolean;
+    /**
+     * The text typeahead matches. Defaults to the text in `children`; set it when that text is
+     * rendered by a component of your own, or differs from what should be typed.
+     */
+    textValue?: string;
     /** Element to render instead of the default `<button>`. Props and ref are merged onto it. */
     render?: ReactElement;
     /** Ref to the rendered element. Merged with any ref on the `render` element. */
@@ -91,25 +109,203 @@ type MenuItemOwnProps = {
 type MenuItemProps = MenuItemOwnProps & Omit<ComponentPropsWithRef<'button'>, keyof MenuItemOwnProps>;
 /**
  * One action. A native `<button>`, so Enter, Space and a click activate it with no key
- * handling here: put the action in `onClick`. Activating it closes the menu — call
- * `event.preventComponentHandler()` in your `onClick` to keep it open.
+ * handling here: put the action in `onClick`. Activating it closes the menu, and every menu
+ * it is nested in — call `event.preventComponentHandler()` in your `onClick` to keep it open.
  *
- * `tabIndex={-1}`: the menu moves focus between items itself, and Tab leaves the menu.
+ * Disabled, your `onClick` is not attached, so an `aria-disabled` item under the Root's
+ * `focusableWhenDisabled` cannot run it either.
+ */
+declare function MenuItem({ disabled, textValue, onClick, className, children, render, ...rest }: MenuItemProps): ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+
+type MenuCheckboxItemOwnProps = {
+    /**
+     * Controlled state. Provide `onCheckedChange` alongside it.
+     *
+     * Never `undefined` once mounted: the mode is latched at mount, as for Checkbox.
+     */
+    checked?: boolean;
+    /** Initial state when uncontrolled. Read once, at mount. */
+    defaultChecked?: boolean;
+    /** Called with the new state, in both controlled and uncontrolled modes. */
+    onCheckedChange?: (checked: boolean) => void;
+    /** Closes the menu when activated. Off by default: a setting is often changed with others. */
+    closeOnClick?: boolean;
+    /**
+     * Cannot be activated. Skipped by the arrow keys, unless the Root sets
+     * `focusableWhenDisabled`.
+     */
+    disabled?: boolean;
+    /** The text typeahead matches. Defaults to the text in `children`. */
+    textValue?: string;
+    /** Element to render instead of the default `<button>`. Props and ref are merged onto it. */
+    render?: ReactElement;
+    /** Ref to the rendered element. Merged with any ref on the `render` element. */
+    ref?: Ref<HTMLElement>;
+};
+type MenuCheckboxItemProps = MenuCheckboxItemOwnProps & Omit<ComponentPropsWithRef<'button'>, keyof MenuCheckboxItemOwnProps>;
+/**
+ * A setting that is on or off: `role="menuitemcheckbox"` with `aria-checked`, on a native
+ * `<button>`. Activating it toggles the state and leaves the menu open, unless `closeOnClick`.
+ * Your `onClick` runs first; `event.preventComponentHandler()` there stops the toggle.
  *
- * Disabled, it is a native `disabled` button, out of focus and activation. With the Root's
- * `focusableWhenDisabled` it is `aria-disabled` instead, which keeps it focusable, so the
- * activation a native `disabled` would block is blocked here: your `onClick` is not
- * attached while it is disabled.
+ * Holds its own state through `useControlled`; an ItemIndicator inside reads it.
  */
-declare function MenuItem({ disabled, onClick, className, children, render, ...rest }: MenuItemProps): ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+declare function MenuCheckboxItem({ checked: checkedProp, defaultChecked, onCheckedChange, closeOnClick, disabled, textValue, onClick, className, children, render, ...rest }: MenuCheckboxItemProps): react.JSX.Element;
 
-declare namespace index_parts {
-  export { MenuItem as Item, MenuPopup as Popup, MenuRoot as Root, MenuTrigger as Trigger };
-}
+type MenuRadioGroupOwnProps = {
+    /**
+     * Controlled value — the `value` of the checked RadioItem, or `null` for none. Provide
+     * `onValueChange` alongside it.
+     *
+     * Never `undefined` once mounted: the mode is latched at mount, as for RadioGroup.
+     */
+    value?: string | null;
+    /** Initial value when uncontrolled. Read once, at mount. */
+    defaultValue?: string | null;
+    /** Called with the value of the RadioItem being checked, in both modes. */
+    onValueChange?: (value: string) => void;
+    /** Disables every RadioItem inside. */
+    disabled?: boolean;
+    /** Element to render instead of the default `<div>`. Props and ref are merged onto it. */
+    render?: ReactElement;
+    /** Ref to the rendered element. Merged with any ref on the `render` element. */
+    ref?: Ref<HTMLElement>;
+};
+type MenuRadioGroupProps = MenuRadioGroupOwnProps & Omit<ComponentPropsWithRef<'div'>, keyof MenuRadioGroupOwnProps | 'defaultValue'>;
+/**
+ * One choice among several: a `role="group"` that owns a value, and the RadioItems inside
+ * derive `checked` from it — as RadioGroup does for radios. Named by a GroupLabel inside, as a
+ * Group is.
+ */
+declare function MenuRadioGroup({ value: valueProp, defaultValue, onValueChange, disabled, className, children, render, ...rest }: MenuRadioGroupProps): react.JSX.Element;
 
-/** The state Menu.Root shares with its parts, and projects as `data-*` attributes. */
-type MenuState = {
-    open: boolean;
+type MenuRadioItemOwnProps = {
+    /** This item's value in its RadioGroup. Checked while the group's `value` equals it. */
+    value: string;
+    /** Closes the menu when activated. Off by default, as for CheckboxItem. */
+    closeOnClick?: boolean;
+    /**
+     * Cannot be activated. Skipped by the arrow keys, unless the Root sets
+     * `focusableWhenDisabled`. The RadioGroup's `disabled` disables it too.
+     */
+    disabled?: boolean;
+    /** The text typeahead matches. Defaults to the text in `children`. */
+    textValue?: string;
+    /** Element to render instead of the default `<button>`. Props and ref are merged onto it. */
+    render?: ReactElement;
+    /** Ref to the rendered element. Merged with any ref on the `render` element. */
+    ref?: Ref<HTMLElement>;
+};
+type MenuRadioItemProps = MenuRadioItemOwnProps & Omit<ComponentPropsWithRef<'button'>, keyof MenuRadioItemOwnProps>;
+/**
+ * One choice in a RadioGroup: `role="menuitemradio"` with `aria-checked`, on a native
+ * `<button>`. Activating it checks it and leaves the menu open, unless `closeOnClick`; the
+ * checked item stays checked when activated again. Your `onClick` runs first;
+ * `event.preventComponentHandler()` there stops the change.
+ */
+declare function MenuRadioItem({ value, closeOnClick, disabled: disabledProp, textValue, onClick, className, children, render, ...rest }: MenuRadioItemProps): react.JSX.Element;
+
+type MenuItemIndicatorOwnProps = {
+    /** Element to render instead of the default `<span>`. Props and ref are merged onto it. */
+    render?: ReactElement;
+    /** Ref to the rendered element. Merged with any ref on the `render` element. */
+    ref?: Ref<HTMLElement>;
+};
+type MenuItemIndicatorProps = MenuItemIndicatorOwnProps & Omit<ComponentPropsWithRef<'span'>, keyof MenuItemIndicatorOwnProps>;
+/**
+ * Where the check goes, in a CheckboxItem or a RadioItem — one part for both, since it reads
+ * the same `checked` from either. Ships no glyph, as Checkbox.Indicator ships none: supply it as
+ * children, or draw it off the `data-*` attributes, which match the item's.
+ *
+ * Always rendered, in every state, so an unchecked item keeps its space and its label lines up
+ * with the checked ones. Hidden from assistive technology: the item announces `aria-checked`.
+ */
+declare function MenuItemIndicator({ className, children, render, ...rest }: MenuItemIndicatorProps): ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+
+type MenuGroupOwnProps = {
+    /** Element to render instead of the default `<div>`. Props and ref are merged onto it. */
+    render?: ReactElement;
+    /** Ref to the rendered element. Merged with any ref on the `render` element. */
+    ref?: Ref<HTMLElement>;
+};
+type MenuGroupProps = MenuGroupOwnProps & Omit<ComponentPropsWithRef<'div'>, keyof MenuGroupOwnProps>;
+/**
+ * Items under a label: `role="group"`, named by its GroupLabel — the menu → group → item
+ * structure APG allows. The arrow keys and typeahead run through every group's items as one
+ * list, past the labels.
+ */
+declare function MenuGroup({ className, children, render, ...rest }: MenuGroupProps): react.JSX.Element;
+
+type MenuGroupLabelOwnProps = {
+    /** Element to render instead of the default `<div>`. Props and ref are merged onto it. */
+    render?: ReactElement;
+    /** Ref to the rendered element. Merged with any ref on the `render` element. */
+    ref?: Ref<HTMLElement>;
 };
+type MenuGroupLabelProps = MenuGroupLabelOwnProps & Omit<ComponentPropsWithRef<'div'>, keyof MenuGroupLabelOwnProps>;
+/**
+ * Names its Group or RadioGroup. Shown in the menu, but not an item: it cannot be activated,
+ * and the arrow keys and typeahead pass it.
+ */
+declare function MenuGroupLabel({ className, children, render, ...rest }: MenuGroupLabelProps): ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+
+type MenuSubmenuRootProps = {
+    /**
+     * Controlled state. Provide `onOpenChange` alongside it.
+     *
+     * Never `undefined` once mounted: the mode is latched at mount, as for Menu.Root.
+     */
+    open?: boolean;
+    /** Initial state when uncontrolled. Read once, at mount. */
+    defaultOpen?: boolean;
+    /**
+     * Called on every request to open or close — its SubmenuTrigger, the arrow keys, an Item,
+     * Esc, a click elsewhere, or the pointer moving to another item of the parent menu.
+     */
+    onOpenChange?: (open: boolean) => void;
+    /** As on Menu.Root. Defaults to the parent menu's setting. */
+    focusableWhenDisabled?: boolean;
+    children?: ReactNode;
+};
+/**
+ * A menu inside a menu: holds the submenu's state, as Root does, and renders no element. Put a
+ * SubmenuTrigger and a Popup inside it; the Popup opens beside the trigger, on the right by
+ * default.
+ *
+ * The popup is a native `popover="auto"` shown with the trigger as its `source`, which nests it
+ * in the parent's popover: the parent stays open while it is, Esc closes one level at a time,
+ * a click in the parent closes only the submenu, and focus returns to the trigger — all the
+ * platform's. Activating an item closes every level.
+ */
+declare function MenuSubmenuRoot({ focusableWhenDisabled, children, ...props }: MenuSubmenuRootProps): react.JSX.Element;
+
+type MenuSubmenuTriggerOwnProps = {
+    /**
+     * Cannot open its submenu. Skipped by the arrow keys, unless the Root sets
+     * `focusableWhenDisabled`.
+     */
+    disabled?: boolean;
+    /** The text typeahead matches in the parent menu. Defaults to the text in `children`. */
+    textValue?: string;
+    /** Element to render instead of the default `<button>`. Props and ref are merged onto it. */
+    render?: ReactElement;
+    /** Ref to the rendered element. Merged with any ref on the `render` element. */
+    ref?: Ref<HTMLElement>;
+};
+type MenuSubmenuTriggerProps = MenuSubmenuTriggerOwnProps & Omit<ComponentPropsWithRef<'button'>, keyof MenuSubmenuTriggerOwnProps>;
+/**
+ * The item that opens a submenu: a `menuitem` of the parent menu with `aria-haspopup="menu"`,
+ * which the submenu is anchored to and named by. It registers with the parent, so the parent's
+ * arrow keys and typeahead reach it.
+ *
+ * Enter, Space and → (← in a right-to-left menu) open the submenu at its first item. Resting the
+ * pointer on it opens it without moving focus; moving to another item of the parent closes it,
+ * unless the pointer is crossing toward the submenu.
+ */
+declare function MenuSubmenuTrigger({ disabled, textValue, onClick, className, children, render, ...rest }: MenuSubmenuTriggerProps): ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+
+declare namespace index_parts {
+  export { MenuCheckboxItem as CheckboxItem, MenuGroup as Group, MenuGroupLabel as GroupLabel, MenuItem as Item, MenuItemIndicator as ItemIndicator, MenuPopup as Popup, MenuRadioGroup as RadioGroup, MenuRadioItem as RadioItem, MenuRoot as Root, MenuSubmenuRoot as SubmenuRoot, MenuSubmenuTrigger as SubmenuTrigger, MenuTrigger as Trigger };
+}
 
-export { index_parts as Menu, type MenuAlign, type MenuItemProps, type MenuPopupProps, type MenuRootProps, type MenuSide, type MenuState, type MenuTriggerProps };
+export { index_parts as Menu, type MenuAlign, type MenuCheckboxItemProps, type MenuGroupLabelProps, type MenuGroupProps, type MenuItemIndicatorProps, type MenuItemProps, type MenuPopupProps, type MenuRadioGroupProps, type MenuRadioItemProps, type MenuRootProps, type MenuSide, type MenuState, type MenuSubmenuRootProps, type MenuSubmenuTriggerProps, type MenuTriggerProps };

package/dist/menu/index.d.ts

@@ -2,6 +2,11 @@ import * as react from 'react';
 import { ReactNode, ReactElement, Ref, ComponentPropsWithRef } from 'react';
 import { A as AnchorSide, a as AnchorAlign } from '../anchoring-Btxi0QwC.js';
 
+/** The state Menu.Root shares with its parts, and projects as `data-*` attributes. */
+type MenuState = {
+    open: boolean;
+};
+
 type MenuRootProps = {
     /**
      * Controlled state. Provide `onOpenChange` alongside it.
@@ -34,7 +39,7 @@ type MenuRootProps = {
  * Each Item registers its own `disabled` from its props; the Root never reads it back from
  * the DOM (decision 10). Elements are kept only to move focus to.
  */
-declare function MenuRoot({ open: openProp, defaultOpen, onOpenChange, focusableWhenDisabled, children, }: MenuRootProps): react.JSX.Element;
+declare function MenuRoot({ children, ...props }: MenuRootProps): react.JSX.Element;
 
 type MenuTriggerOwnProps = {
     /** Element to render instead of the default `<button>`. Props and ref are merged onto it. */
@@ -53,7 +58,10 @@ declare function MenuTrigger({ className, children, render, ...rest }: MenuTrigg
 type MenuSide = AnchorSide;
 type MenuAlign = AnchorAlign;
 type MenuPopupOwnProps = {
-    /** Which side of the trigger to open on. Flips to the opposite side when there is no room. */
+    /**
+     * Which side of the trigger to open on. Flips to the opposite side when there is no room.
+     * Defaults to `'bottom'`, and to `'right'` in a submenu.
+     */
     side?: MenuSide;
     /** Where along that side: flush with the trigger's start or end edge, or centred on it. */
     align?: MenuAlign;
@@ -68,14 +76,19 @@ type MenuPopupProps = MenuPopupOwnProps & Omit<ComponentPropsWithRef<'div'>, key
  * Popover's popup is (decision 12), and labelled by it.
  *
  * Opening moves focus to the first item — the last, when Up on the Trigger opened it. Up
- * and Down then move between items, wrapping, with Home and End; disabled items are skipped
- * unless the Root sets `focusableWhenDisabled`. Tab closes the menu and lets focus move on.
+ * and Down then move between items, wrapping, with Home and End; typing moves to the next item
+ * whose text starts with what was typed. Disabled items are skipped by both, unless the Root
+ * sets `focusableWhenDisabled`. Tab closes the menu and lets focus move on.
+ *
+ * Inside a SubmenuRoot it is that submenu's popup: it opens beside its SubmenuTrigger, ← (→ in
+ * a right-to-left menu) closes it, and Tab closes every level. Closing with focus inside returns
+ * it to the SubmenuTrigger.
  *
  * Light dismiss and Esc close the element before anyone is asked; the `toggle` event
  * reports it through the Root, and the element reopens if the state stays open. Focus
  * returns to the Trigger, the invoker, whenever the menu hides with focus inside it.
  */
-declare function MenuPopup({ side, align, className, children, render, ...rest }: MenuPopupProps): ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+declare function MenuPopup({ side: sideProp, align, className, children, render, ...rest }: MenuPopupProps): ReactElement<unknown, string | react.JSXElementConstructor<any>>;
 
 type MenuItemOwnProps = {
     /**
@@ -83,6 +96,11 @@ type MenuItemOwnProps = {
      * `focusableWhenDisabled`.
      */
     disabled?: boolean;
+    /**
+     * The text typeahead matches. Defaults to the text in `children`; set it when that text is
+     * rendered by a component of your own, or differs from what should be typed.
+     */
+    textValue?: string;
     /** Element to render instead of the default `<button>`. Props and ref are merged onto it. */
     render?: ReactElement;
     /** Ref to the rendered element. Merged with any ref on the `render` element. */
@@ -91,25 +109,203 @@ type MenuItemOwnProps = {
 type MenuItemProps = MenuItemOwnProps & Omit<ComponentPropsWithRef<'button'>, keyof MenuItemOwnProps>;
 /**
  * One action. A native `<button>`, so Enter, Space and a click activate it with no key
- * handling here: put the action in `onClick`. Activating it closes the menu — call
- * `event.preventComponentHandler()` in your `onClick` to keep it open.
+ * handling here: put the action in `onClick`. Activating it closes the menu, and every menu
+ * it is nested in — call `event.preventComponentHandler()` in your `onClick` to keep it open.
  *
- * `tabIndex={-1}`: the menu moves focus between items itself, and Tab leaves the menu.
+ * Disabled, your `onClick` is not attached, so an `aria-disabled` item under the Root's
+ * `focusableWhenDisabled` cannot run it either.
+ */
+declare function MenuItem({ disabled, textValue, onClick, className, children, render, ...rest }: MenuItemProps): ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+
+type MenuCheckboxItemOwnProps = {
+    /**
+     * Controlled state. Provide `onCheckedChange` alongside it.
+     *
+     * Never `undefined` once mounted: the mode is latched at mount, as for Checkbox.
+     */
+    checked?: boolean;
+    /** Initial state when uncontrolled. Read once, at mount. */
+    defaultChecked?: boolean;
+    /** Called with the new state, in both controlled and uncontrolled modes. */
+    onCheckedChange?: (checked: boolean) => void;
+    /** Closes the menu when activated. Off by default: a setting is often changed with others. */
+    closeOnClick?: boolean;
+    /**
+     * Cannot be activated. Skipped by the arrow keys, unless the Root sets
+     * `focusableWhenDisabled`.
+     */
+    disabled?: boolean;
+    /** The text typeahead matches. Defaults to the text in `children`. */
+    textValue?: string;
+    /** Element to render instead of the default `<button>`. Props and ref are merged onto it. */
+    render?: ReactElement;
+    /** Ref to the rendered element. Merged with any ref on the `render` element. */
+    ref?: Ref<HTMLElement>;
+};
+type MenuCheckboxItemProps = MenuCheckboxItemOwnProps & Omit<ComponentPropsWithRef<'button'>, keyof MenuCheckboxItemOwnProps>;
+/**
+ * A setting that is on or off: `role="menuitemcheckbox"` with `aria-checked`, on a native
+ * `<button>`. Activating it toggles the state and leaves the menu open, unless `closeOnClick`.
+ * Your `onClick` runs first; `event.preventComponentHandler()` there stops the toggle.
  *
- * Disabled, it is a native `disabled` button, out of focus and activation. With the Root's
- * `focusableWhenDisabled` it is `aria-disabled` instead, which keeps it focusable, so the
- * activation a native `disabled` would block is blocked here: your `onClick` is not
- * attached while it is disabled.
+ * Holds its own state through `useControlled`; an ItemIndicator inside reads it.
  */
-declare function MenuItem({ disabled, onClick, className, children, render, ...rest }: MenuItemProps): ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+declare function MenuCheckboxItem({ checked: checkedProp, defaultChecked, onCheckedChange, closeOnClick, disabled, textValue, onClick, className, children, render, ...rest }: MenuCheckboxItemProps): react.JSX.Element;
 
-declare namespace index_parts {
-  export { MenuItem as Item, MenuPopup as Popup, MenuRoot as Root, MenuTrigger as Trigger };
-}
+type MenuRadioGroupOwnProps = {
+    /**
+     * Controlled value — the `value` of the checked RadioItem, or `null` for none. Provide
+     * `onValueChange` alongside it.
+     *
+     * Never `undefined` once mounted: the mode is latched at mount, as for RadioGroup.
+     */
+    value?: string | null;
+    /** Initial value when uncontrolled. Read once, at mount. */
+    defaultValue?: string | null;
+    /** Called with the value of the RadioItem being checked, in both modes. */
+    onValueChange?: (value: string) => void;
+    /** Disables every RadioItem inside. */
+    disabled?: boolean;
+    /** Element to render instead of the default `<div>`. Props and ref are merged onto it. */
+    render?: ReactElement;
+    /** Ref to the rendered element. Merged with any ref on the `render` element. */
+    ref?: Ref<HTMLElement>;
+};
+type MenuRadioGroupProps = MenuRadioGroupOwnProps & Omit<ComponentPropsWithRef<'div'>, keyof MenuRadioGroupOwnProps | 'defaultValue'>;
+/**
+ * One choice among several: a `role="group"` that owns a value, and the RadioItems inside
+ * derive `checked` from it — as RadioGroup does for radios. Named by a GroupLabel inside, as a
+ * Group is.
+ */
+declare function MenuRadioGroup({ value: valueProp, defaultValue, onValueChange, disabled, className, children, render, ...rest }: MenuRadioGroupProps): react.JSX.Element;
 
-/** The state Menu.Root shares with its parts, and projects as `data-*` attributes. */
-type MenuState = {
-    open: boolean;
+type MenuRadioItemOwnProps = {
+    /** This item's value in its RadioGroup. Checked while the group's `value` equals it. */
+    value: string;
+    /** Closes the menu when activated. Off by default, as for CheckboxItem. */
+    closeOnClick?: boolean;
+    /**
+     * Cannot be activated. Skipped by the arrow keys, unless the Root sets
+     * `focusableWhenDisabled`. The RadioGroup's `disabled` disables it too.
+     */
+    disabled?: boolean;
+    /** The text typeahead matches. Defaults to the text in `children`. */
+    textValue?: string;
+    /** Element to render instead of the default `<button>`. Props and ref are merged onto it. */
+    render?: ReactElement;
+    /** Ref to the rendered element. Merged with any ref on the `render` element. */
+    ref?: Ref<HTMLElement>;
+};
+type MenuRadioItemProps = MenuRadioItemOwnProps & Omit<ComponentPropsWithRef<'button'>, keyof MenuRadioItemOwnProps>;
+/**
+ * One choice in a RadioGroup: `role="menuitemradio"` with `aria-checked`, on a native
+ * `<button>`. Activating it checks it and leaves the menu open, unless `closeOnClick`; the
+ * checked item stays checked when activated again. Your `onClick` runs first;
+ * `event.preventComponentHandler()` there stops the change.
+ */
+declare function MenuRadioItem({ value, closeOnClick, disabled: disabledProp, textValue, onClick, className, children, render, ...rest }: MenuRadioItemProps): react.JSX.Element;
+
+type MenuItemIndicatorOwnProps = {
+    /** Element to render instead of the default `<span>`. Props and ref are merged onto it. */
+    render?: ReactElement;
+    /** Ref to the rendered element. Merged with any ref on the `render` element. */
+    ref?: Ref<HTMLElement>;
+};
+type MenuItemIndicatorProps = MenuItemIndicatorOwnProps & Omit<ComponentPropsWithRef<'span'>, keyof MenuItemIndicatorOwnProps>;
+/**
+ * Where the check goes, in a CheckboxItem or a RadioItem — one part for both, since it reads
+ * the same `checked` from either. Ships no glyph, as Checkbox.Indicator ships none: supply it as
+ * children, or draw it off the `data-*` attributes, which match the item's.
+ *
+ * Always rendered, in every state, so an unchecked item keeps its space and its label lines up
+ * with the checked ones. Hidden from assistive technology: the item announces `aria-checked`.
+ */
+declare function MenuItemIndicator({ className, children, render, ...rest }: MenuItemIndicatorProps): ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+
+type MenuGroupOwnProps = {
+    /** Element to render instead of the default `<div>`. Props and ref are merged onto it. */
+    render?: ReactElement;
+    /** Ref to the rendered element. Merged with any ref on the `render` element. */
+    ref?: Ref<HTMLElement>;
+};
+type MenuGroupProps = MenuGroupOwnProps & Omit<ComponentPropsWithRef<'div'>, keyof MenuGroupOwnProps>;
+/**
+ * Items under a label: `role="group"`, named by its GroupLabel — the menu → group → item
+ * structure APG allows. The arrow keys and typeahead run through every group's items as one
+ * list, past the labels.
+ */
+declare function MenuGroup({ className, children, render, ...rest }: MenuGroupProps): react.JSX.Element;
+
+type MenuGroupLabelOwnProps = {
+    /** Element to render instead of the default `<div>`. Props and ref are merged onto it. */
+    render?: ReactElement;
+    /** Ref to the rendered element. Merged with any ref on the `render` element. */
+    ref?: Ref<HTMLElement>;
 };
+type MenuGroupLabelProps = MenuGroupLabelOwnProps & Omit<ComponentPropsWithRef<'div'>, keyof MenuGroupLabelOwnProps>;
+/**
+ * Names its Group or RadioGroup. Shown in the menu, but not an item: it cannot be activated,
+ * and the arrow keys and typeahead pass it.
+ */
+declare function MenuGroupLabel({ className, children, render, ...rest }: MenuGroupLabelProps): ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+
+type MenuSubmenuRootProps = {
+    /**
+     * Controlled state. Provide `onOpenChange` alongside it.
+     *
+     * Never `undefined` once mounted: the mode is latched at mount, as for Menu.Root.
+     */
+    open?: boolean;
+    /** Initial state when uncontrolled. Read once, at mount. */
+    defaultOpen?: boolean;
+    /**
+     * Called on every request to open or close — its SubmenuTrigger, the arrow keys, an Item,
+     * Esc, a click elsewhere, or the pointer moving to another item of the parent menu.
+     */
+    onOpenChange?: (open: boolean) => void;
+    /** As on Menu.Root. Defaults to the parent menu's setting. */
+    focusableWhenDisabled?: boolean;
+    children?: ReactNode;
+};
+/**
+ * A menu inside a menu: holds the submenu's state, as Root does, and renders no element. Put a
+ * SubmenuTrigger and a Popup inside it; the Popup opens beside the trigger, on the right by
+ * default.
+ *
+ * The popup is a native `popover="auto"` shown with the trigger as its `source`, which nests it
+ * in the parent's popover: the parent stays open while it is, Esc closes one level at a time,
+ * a click in the parent closes only the submenu, and focus returns to the trigger — all the
+ * platform's. Activating an item closes every level.
+ */
+declare function MenuSubmenuRoot({ focusableWhenDisabled, children, ...props }: MenuSubmenuRootProps): react.JSX.Element;
+
+type MenuSubmenuTriggerOwnProps = {
+    /**
+     * Cannot open its submenu. Skipped by the arrow keys, unless the Root sets
+     * `focusableWhenDisabled`.
+     */
+    disabled?: boolean;
+    /** The text typeahead matches in the parent menu. Defaults to the text in `children`. */
+    textValue?: string;
+    /** Element to render instead of the default `<button>`. Props and ref are merged onto it. */
+    render?: ReactElement;
+    /** Ref to the rendered element. Merged with any ref on the `render` element. */
+    ref?: Ref<HTMLElement>;
+};
+type MenuSubmenuTriggerProps = MenuSubmenuTriggerOwnProps & Omit<ComponentPropsWithRef<'button'>, keyof MenuSubmenuTriggerOwnProps>;
+/**
+ * The item that opens a submenu: a `menuitem` of the parent menu with `aria-haspopup="menu"`,
+ * which the submenu is anchored to and named by. It registers with the parent, so the parent's
+ * arrow keys and typeahead reach it.
+ *
+ * Enter, Space and → (← in a right-to-left menu) open the submenu at its first item. Resting the
+ * pointer on it opens it without moving focus; moving to another item of the parent closes it,
+ * unless the pointer is crossing toward the submenu.
+ */
+declare function MenuSubmenuTrigger({ disabled, textValue, onClick, className, children, render, ...rest }: MenuSubmenuTriggerProps): ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+
+declare namespace index_parts {
+  export { MenuCheckboxItem as CheckboxItem, MenuGroup as Group, MenuGroupLabel as GroupLabel, MenuItem as Item, MenuItemIndicator as ItemIndicator, MenuPopup as Popup, MenuRadioGroup as RadioGroup, MenuRadioItem as RadioItem, MenuRoot as Root, MenuSubmenuRoot as SubmenuRoot, MenuSubmenuTrigger as SubmenuTrigger, MenuTrigger as Trigger };
+}
 
-export { index_parts as Menu, type MenuAlign, type MenuItemProps, type MenuPopupProps, type MenuRootProps, type MenuSide, type MenuState, type MenuTriggerProps };
+export { index_parts as Menu, type MenuAlign, type MenuCheckboxItemProps, type MenuGroupLabelProps, type MenuGroupProps, type MenuItemIndicatorProps, type MenuItemProps, type MenuPopupProps, type MenuRadioGroupProps, type MenuRadioItemProps, type MenuRootProps, type MenuSide, type MenuState, type MenuSubmenuRootProps, type MenuSubmenuTriggerProps, type MenuTriggerProps };