import type { ARIAButtonElement } from '@fluentui/react-aria';
import type { ForwardRefComponent } from '@fluentui/react-utilities';
import type { JSXElement } from '@fluentui/react-utilities';
import { MenuContextValue } from '@fluentui/react-menu';
import { MenuDividerProps } from '@fluentui/react-menu';
import { MenuDividerSlots } from '@fluentui/react-menu';
import { MenuDividerState } from '@fluentui/react-menu';
import { MenuGroupContextValues } from '@fluentui/react-menu';
import { MenuGroupHeaderProps } from '@fluentui/react-menu';
import { MenuGroupHeaderSlots } from '@fluentui/react-menu';
import { MenuGroupHeaderState } from '@fluentui/react-menu';
import { MenuGroupProps } from '@fluentui/react-menu';
import { MenuGroupSlots } from '@fluentui/react-menu';
import { MenuGroupState } from '@fluentui/react-menu';
import { MenuItemCheckboxProps } from '@fluentui/react-menu';
import { MenuItemCheckboxState } from '@fluentui/react-menu';
import { MenuItemLinkProps } from '@fluentui/react-menu';
import { MenuItemLinkSlots } from '@fluentui/react-menu';
import { MenuItemLinkState } from '@fluentui/react-menu';
import type { MenuItemProps as MenuItemProps_2 } from '@fluentui/react-menu';
import type { MenuItemRadioBaseProps } from '@fluentui/react-menu';
import type { MenuItemRadioBaseState } from '@fluentui/react-menu';
import { MenuItemSlots } from '@fluentui/react-menu';
import type { MenuItemState as MenuItemState_2 } from '@fluentui/react-menu';
import { MenuItemSwitchProps } from '@fluentui/react-menu';
import { MenuItemSwitchSlots } from '@fluentui/react-menu';
import { MenuItemSwitchState } from '@fluentui/react-menu';
import type { MenuListContextValues } from '@fluentui/react-menu';
import type { MenuListProps as MenuListProps_2 } from '@fluentui/react-menu';
import type { MenuListSlots } from '@fluentui/react-menu';
import type { MenuListState as MenuListState_2 } from '@fluentui/react-menu';
import { MenuOpenChangeData } from '@fluentui/react-menu';
import { MenuOpenEvent } from '@fluentui/react-menu';
import { MenuPopoverProps } from '@fluentui/react-menu';
import { MenuPopoverSlots } from '@fluentui/react-menu';
import { MenuPopoverState } from '@fluentui/react-menu';
import { MenuBaseProps as MenuProps } from '@fluentui/react-menu';
import { MenuSplitGroupProps } from '@fluentui/react-menu';
import { MenuSplitGroupSlots } from '@fluentui/react-menu';
import { MenuSplitGroupState } from '@fluentui/react-menu';
import { MenuBaseState as MenuState } from '@fluentui/react-menu';
import { MenuTriggerChildProps } from '@fluentui/react-menu';
import { MenuTriggerProps } from '@fluentui/react-menu';
import { MenuTriggerState } from '@fluentui/react-menu';
import * as React_2 from 'react';
import { renderMenuDivider_unstable as renderMenuDivider } from '@fluentui/react-menu';
import { renderMenuGroup_unstable as renderMenuGroup } from '@fluentui/react-menu';
import { renderMenuGroupHeader_unstable as renderMenuGroupHeader } from '@fluentui/react-menu';
import { renderMenuItem_unstable as renderMenuItem } from '@fluentui/react-menu';
import { renderMenuItemCheckbox_unstable as renderMenuItemCheckbox } from '@fluentui/react-menu';
import { renderMenuItemLink_unstable as renderMenuItemLink } from '@fluentui/react-menu';
import { renderMenuItemRadio_unstable as renderMenuItemRadio } from '@fluentui/react-menu';
import { renderMenuItemSwitch_unstable as renderMenuItemSwitch } from '@fluentui/react-menu';
import { renderMenuSplitGroup_unstable as renderMenuSplitGroup } from '@fluentui/react-menu';
import { renderMenuTrigger_unstable as renderMenuTrigger } from '@fluentui/react-menu';
import { useMenuContext_unstable as useMenuContext } from '@fluentui/react-menu';
import { useMenuDivider_unstable as useMenuDivider } from '@fluentui/react-menu';
import { useMenuGroup_unstable as useMenuGroup } from '@fluentui/react-menu';
import { useMenuGroupContextValues_unstable as useMenuGroupContextValues } from '@fluentui/react-menu';
import { useMenuGroupHeader_unstable as useMenuGroupHeader } from '@fluentui/react-menu';
import { useMenuListContextValues_unstable as useMenuListContextValues } from '@fluentui/react-menu';

/**
 * Headless Menu component.
 */
export declare const Menu: React_2.FC<MenuProps>;

export { MenuContextValue }

export declare type MenuContextValues = {
    menu: MenuContextValue;
};

/**
 * Headless MenuDivider component.
 *
 * Renders an `aria-hidden` `role="presentation"` separator inside a MenuList.
 */
export declare const MenuDivider: ForwardRefComponent<MenuDividerProps>;

export { MenuDividerProps }

export { MenuDividerSlots }

export { MenuDividerState }

/**
 * Headless MenuGroup component.
 *
 * Wraps a logical group of menu items, exposing a `headerId` through context
 * so that an optional `MenuGroupHeader` child can wire `aria-labelledby`.
 */
export declare const MenuGroup: ForwardRefComponent<MenuGroupProps>;

export { MenuGroupContextValues }

/**
 * Headless MenuGroupHeader component.
 *
 * Renders the labelled header for a `MenuGroup` and stamps the group's
 * `headerId` on its root.
 */
export declare const MenuGroupHeader: ForwardRefComponent<MenuGroupHeaderProps>;

export { MenuGroupHeaderProps }

export { MenuGroupHeaderSlots }

export { MenuGroupHeaderState }

export { MenuGroupProps }

export { MenuGroupSlots }

export { MenuGroupState }

/**
 * Headless MenuItem component.
 *
 * Renders a `role="menuitem"` element with ARIA-button semantics, character
 * search wiring, and click-to-dismiss handling. Submenu indicator is opt-in
 * via the `submenuIndicator` slot — no default icon is injected.
 */
export declare const MenuItem: ForwardRefComponent<MenuItemProps>;

/**
 * Headless MenuItemCheckbox component.
 *
 * Renders a multi-select item with `role="menuitemcheckbox"` and ARIA
 * `aria-checked` driven by the parent MenuList's controlled `checkedValues`.
 */
export declare const MenuItemCheckbox: ForwardRefComponent<MenuItemCheckboxProps_2>;

export { MenuItemCheckboxProps }

declare type MenuItemCheckboxProps_2 = MenuItemCheckboxProps;

export { MenuItemCheckboxState }

declare type MenuItemCheckboxState_2 = MenuItemCheckboxState & {
    root: {
        'data-disabled'?: string;
        'data-has-submenu'?: string;
        'data-submenu-open'?: string;
        'data-checked'?: string;
    };
};

/**
 * Headless MenuItemLink component.
 *
 * Renders an anchor (`<a>`) with `role="menuitem"` for navigational menu
 * items. Click follows the supplied `href`.
 */
export declare const MenuItemLink: ForwardRefComponent<MenuItemLinkProps_2>;

export { MenuItemLinkProps }

declare type MenuItemLinkProps_2 = MenuItemLinkProps;

export { MenuItemLinkSlots }

export { MenuItemLinkState }

declare type MenuItemLinkState_2 = MenuItemLinkState & {
    root: {
        'data-disabled'?: string;
    };
};

export declare type MenuItemProps = MenuItemProps_2;

/**
 * Headless MenuItemRadio component.
 */
export declare const MenuItemRadio: ForwardRefComponent<MenuItemRadioProps>;

export declare type MenuItemRadioProps = MenuItemRadioBaseProps;

export declare type MenuItemRadioState = MenuItemRadioBaseState & {
    root: {
        'data-disabled'?: string;
        'data-has-submenu'?: string;
        'data-submenu-open'?: string;
        'data-checked'?: string;
    };
};

export { MenuItemSlots }

export declare type MenuItemState = MenuItemState_2 & {
    root: {
        focusgroupstart?: string;
        'data-disabled'?: string;
        'data-has-submenu'?: string;
        'data-submenu-open'?: string;
    };
};

/**
 * Headless MenuItemSwitch component.
 *
 * Renders a toggle-style menu item with a `switchIndicator` slot. Selection
 * state is driven by the parent MenuList's controlled `checkedValues`.
 */
export declare const MenuItemSwitch: ForwardRefComponent<MenuItemSwitchProps_2>;

export { MenuItemSwitchProps }

declare type MenuItemSwitchProps_2 = MenuItemSwitchProps;

export { MenuItemSwitchSlots }

export { MenuItemSwitchState }

declare type MenuItemSwitchState_2 = MenuItemSwitchState & {
    root: {
        'data-disabled'?: string;
        'data-checked'?: string;
    };
};

/**
 * Headless MenuList component.
 */
export declare const MenuList: ForwardRefComponent<MenuListProps>;

export declare type MenuListProps = MenuListProps_2;

export { MenuListSlots }

export declare type MenuListState = MenuListState_2 & {
    root: {
        focusgroup?: string;
    };
};

export { MenuOpenChangeData }

export { MenuOpenEvent }

export declare const MenuPopover: ForwardRefComponent<MenuPopoverProps>;

export { MenuPopoverProps }

export { MenuPopoverSlots }

export { MenuPopoverState }

export { MenuProps }

export declare const MenuSplitGroup: ForwardRefComponent<MenuSplitGroupProps>;

export { MenuSplitGroupProps }

export { MenuSplitGroupSlots }

export { MenuSplitGroupState }

export { MenuState }

/**
 * Headless MenuTrigger component.
 *
 * Clones its single child and applies the menu trigger props (ARIA, event
 * handlers, ref merging) needed to drive the parent Menu's open state.
 */
export declare const MenuTrigger: React_2.FC<MenuTriggerProps>;

export { MenuTriggerChildProps }

export { MenuTriggerProps }

export { MenuTriggerState }

export declare const renderMenu: (state: MenuState, contextValues: MenuContextValues) => JSXElement;

export { renderMenuDivider }

export { renderMenuGroup }

export { renderMenuGroupHeader }

export { renderMenuItem }

export { renderMenuItemCheckbox }

export { renderMenuItemLink }

export { renderMenuItemRadio }

export { renderMenuItemSwitch }

export declare const renderMenuList: (state: MenuListState_2, contextValues: MenuListContextValues) => JSXElement;

export declare const renderMenuPopover: (state: MenuPopoverState) => JSXElement;

export { renderMenuSplitGroup }

export { renderMenuTrigger }

export declare const useMenu: (props: MenuProps) => MenuState;

export { useMenuContext }

export declare const useMenuContextValues: (state: MenuState) => MenuContextValues;

export { useMenuDivider }

export { useMenuGroup }

export { useMenuGroupContextValues }

export { useMenuGroupHeader }

/** Returns the state for a MenuItem; adds `focusgroupstart` so the focusgroup polyfill anchors the initial tab stop on the first item. */
export declare const useMenuItem: (props: MenuItemProps, ref: React_2.Ref<ARIAButtonElement<"div">>) => MenuItemState;

export declare const useMenuItemCheckbox: (props: MenuItemCheckboxProps_2, ref: React_2.Ref<ARIAButtonElement<"div">>) => MenuItemCheckboxState_2;

export declare const useMenuItemLink: (props: MenuItemLinkProps_2, ref: React_2.Ref<HTMLAnchorElement>) => MenuItemLinkState_2;

export declare const useMenuItemRadio: (props: MenuItemRadioProps, ref: React_2.Ref<ARIAButtonElement<"div">>) => MenuItemRadioState;

export declare const useMenuItemSwitch: (props: MenuItemSwitchProps_2, ref: React_2.Ref<HTMLDivElement>) => MenuItemSwitchState_2;

/**
 * Returns the state for a MenuList.
 * Uses the native focusgroup attribute for arrow key navigation. Focus is moved
 * into the list by MenuPopover via the HTML autofocus attribute on the first
 * focusable MenuItem (set imperatively because React skips autoFocus on divs).
 */
export declare const useMenuList: (props: MenuListProps, ref: React_2.Ref<HTMLElement>) => MenuListState;

export { useMenuListContextValues }

export declare const useMenuPopover: (props: MenuPopoverProps, ref: React_2.Ref<HTMLElement>) => MenuPopoverState;

/**
 * Headless `useMenuSplitGroup`.
 * Renders a `role="group"` div and wires the consumer ref.
 */
export declare const useMenuSplitGroup: (props: MenuSplitGroupProps, ref: React_2.Ref<HTMLElement>) => MenuSplitGroupState;

export declare const useMenuTrigger: (props: MenuTriggerProps) => MenuTriggerState;

export { }