import React from 'react';
import { type AriaMenuProps } from 'react-aria';
import { Section } from '@react-stately/collections';
import type { ItemProps } from '@react-types/shared';
export interface MenuProps<T extends object> extends AriaMenuProps<T> {
    className?: string;
    style?: React.CSSProperties;
}
export interface MenuItemProps<T extends object = object> extends ItemProps<T> {
    /**
     * Only on a row that opens a submenu: the row's label. Its children are then
     * the submenu's MenuItems rather than its label. Submenus open only inside a
     * MenuTrigger — a standalone Menu has nothing to open them from.
     */
    title?: React.ReactNode;
    /** Figma's `Show Leading Icon` + `Leading Icon` swap. */
    icon?: React.ReactNode;
    /** Whether the item is disabled. Listed, skipped by the arrow keys. */
    isDisabled?: boolean;
    /**
     * @deprecated Use `isDisabled`. Accepted as an alias for one minor version.
     */
    disabled?: boolean;
    /**
     * @deprecated Put the item's key in Menu's `selectedKeys`. Accepted for one
     * minor version: when no item's key is in `selectedKeys` and Menu is given
     * neither `selectedKeys` nor `defaultSelectedKeys`, the items passing this
     * become the selection.
     */
    isSelected?: boolean;
}
/**
 * One row of a Menu. A collection element, like TabItem: it renders nothing
 * itself — Menu reads its props and draws the row — so it only means anything
 * as a direct child of Menu or MenuSection. Give it a `key`; that key is what
 * `onAction` and `selectedKeys` speak in.
 */
export declare function MenuItem<T extends object>(_props: MenuItemProps<T>): React.ReactElement | null;
export declare namespace MenuItem {
    var displayName: string;
}
/**
 * A named group of MenuItems. `title` is Figma's `Menu Section Title`; without
 * one, pass `aria-label` and the group is set off by a rule instead.
 */
export { Section as MenuSection };
/**
 * Menu — Figma `Menu` (82:306), `Menu Item` and `Menu Section Title`.
 *
 * A real ARIA menu: `role="menu"`, one tab stop, arrow keys, Home and End,
 * typeahead, and disabled rows listed but skipped. Figma's `Type` is
 * `selectionMode` — Single draws one check, Multi draws several — and with
 * a selection mode the rows become `menuitemradio` / `menuitemcheckbox` and
 * announce their checked state.
 *
 * On its own it is the surface only, rendered in flow. Inside a MenuTrigger it
 * floats, opens and closes, is named by its trigger, and can open submenus.
 */
export declare const Menu: <T extends object>(props: MenuProps<T> & {
    ref?: React.Ref<HTMLUListElement>;
}) => React.ReactElement;
export type MenuTriggerPlacement = 'bottom start' | 'bottom end' | 'top start' | 'top end';
export interface MenuTriggerProps {
    /**
     * Exactly two children: the Button that opens the menu, then the Menu. The
     * Button must accept a ref and react-aria press props — IonBase's Button
     * does; a plain `<button>` does not.
     */
    children: [React.ReactElement, React.ReactElement];
    /**
     * Where the menu opens, relative to the trigger. A preference, not a
     * guarantee: it flips when there is no room.
     */
    placement?: MenuTriggerPlacement;
    /** Whether the trigger is disabled. */
    isDisabled?: boolean;
    isOpen?: boolean;
    defaultOpen?: boolean;
    onOpenChange?: (isOpen: boolean) => void;
}
/**
 * MenuTrigger — a Button that opens a Menu.
 *
 * The "⋯" overflow menu is this with an icon-only Button; there is no separate
 * component for it, because the only difference is the Button's content and
 * its required aria-label.
 *
 * `useMenuTrigger` does what a Popover wrapped round a Menu could not: the
 * trigger announces `aria-haspopup="menu"` and `aria-expanded`, the menu is
 * named by the trigger, ArrowDown and ArrowUp open it with focus on the first
 * or last row, and choosing an action closes it and returns focus to the
 * trigger.
 */
export declare function MenuTrigger({ children, placement, isDisabled, ...stateProps }: MenuTriggerProps): React.JSX.Element;
export declare namespace MenuTrigger {
    var displayName: string;
}
export interface ContextMenuProps {
    /**
     * The thing the menu is for — a table row, a card, a file. One element; it
     * receives the right-click and keyboard handlers, and keeps its own. It
     * must pass `onContextMenu` and `onKeyDown` through to the DOM, as
     * IonBase's TableRow and any host element do.
     */
    children: React.ReactElement;
    /** The Menu to open, with its MenuItems and `onAction`. */
    menu: React.ReactElement;
    /**
     * The menu's name, since no button names it: "Actions for Invoice
     * reconciler". Required.
     */
    'aria-label': string;
    /** Leaves the browser's own menu in place. */
    isDisabled?: boolean;
    onOpenChange?: (isOpen: boolean) => void;
}
/**
 * ContextMenu — the menu a right-click opens on a thing: a row's actions, a
 * file's. Shift+F10 and the Menu key open it from the keyboard, anchored to
 * the thing rather than to a pointer that is not there.
 *
 * A SHORTCUT, NEVER THE ONLY WAY. Nothing on the page says a right-click
 * does anything, touch screens have no right-click, and on iOS a long press
 * opens the browser's callout instead. Every action in a context menu must
 * also be reachable without it — the row's own actions menu, a button, a
 * toolbar. The menu is the same Menu, so it can be the same items.
 *
 * HOW IT OPENS
 *
 *   - Right-click: at the pointer, as a desktop app's does. The browser's own
 *     menu is prevented, and only on this element.
 *   - Shift+F10 or the Menu key, with focus on the element or anything in it:
 *     under the element, at its start edge. Focus moves to the first item.
 *   - Escape, an outside click or choosing an item closes it and returns focus
 *     to where it was — the row's link, the card.
 *
 * A second right-click on the element moves the open menu there, rather than
 * opening the browser's menu over it; one elsewhere closes ours.
 */
export declare function ContextMenu({ children, menu, 'aria-label': ariaLabel, isDisabled, onOpenChange, }: ContextMenuProps): React.JSX.Element;
export declare namespace ContextMenu {
    var displayName: string;
}
//# sourceMappingURL=Menu.d.ts.map