@ansh-ui/vue 0.2.0

package/dist/overlay.d.ts

@@ -0,0 +1,772 @@
+import * as vue from 'vue';
+import { PropType, Ref, VNode } from 'vue';
+import { P as Placement } from './position-Cn7qP1pn.js';
+import { S as SlotContent } from './utils-IKPG3zcC.js';
+
+declare const Popover: vue.DefineComponent<vue.ExtractPropTypes<{
+    open: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    defaultOpen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    placement: {
+        type: PropType<Placement>;
+        default: string;
+    };
+    /** Gap from the trigger, in px. Default `8`. */
+    offset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Trap focus and block interaction behind. Default `false` — most popovers are non-modal. */
+    modal: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:open"[], "update:open", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    open: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    defaultOpen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    placement: {
+        type: PropType<Placement>;
+        default: string;
+    };
+    /** Gap from the trigger, in px. Default `8`. */
+    offset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Trap focus and block interaction behind. Default `false` — most popovers are non-modal. */
+    modal: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:open"?: ((...args: any[]) => any) | undefined;
+}>, {
+    open: boolean;
+    placement: Placement;
+    offset: number;
+    defaultOpen: boolean;
+    modal: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const PopoverTrigger: vue.DefineComponent<vue.ExtractPropTypes<{
+    /** Tag to render. Default `'button'`. */
+    as: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    /** Tag to render. Default `'button'`. */
+    as: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    as: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const PopoverContent: vue.DefineComponent<vue.ExtractPropTypes<{
+    /** Draw an arrow pointing at the trigger. Default `false`. */
+    arrow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Match the trigger's width — for a popover acting as a dropdown panel. */
+    matchWidth: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Accessible name. Required unless the content contains its own heading. */
+    label: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    /** Draw an arrow pointing at the trigger. Default `false`. */
+    arrow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Match the trigger's width — for a popover acting as a dropdown panel. */
+    matchWidth: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Accessible name. Required unless the content contains its own heading. */
+    label: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    label: string;
+    matchWidth: boolean;
+    arrow: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+/**
+ * A rich preview shown on hover — a user card on an @mention, a link preview.
+ *
+ * Two delays, not one. The open delay stops cards firing as the pointer sweeps across a paragraph of
+ * links. The close delay is what lets the pointer travel from the trigger to the card without it
+ * vanishing en route, which is the failure that makes hover cards feel broken.
+ *
+ * Hover-only content is invisible to keyboard and touch users, so this also opens on focus. It is
+ * strictly for *supplementary* information — anything essential belongs in a click-opened popover.
+ *
+ * The React version takes the card's body as a `content` prop; here it's the `#content` slot and
+ * the trigger is the default slot — passing a render tree through a prop is idiomatic React and
+ * awkward Vue, so this is one of the few places the two APIs deliberately differ:
+ * ```vue
+ * <HoverCard>
+ *   @user
+ *   <template #content>…</template>
+ * </HoverCard>
+ * ```
+ */
+declare const HoverCard: vue.DefineComponent<vue.ExtractPropTypes<{
+    /** Delay before opening, in ms. Default `500`. */
+    openDelay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Delay before closing, in ms. Default `200`. */
+    closeDelay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    placement: {
+        type: PropType<Placement>;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    /** Delay before opening, in ms. Default `500`. */
+    openDelay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** Delay before closing, in ms. Default `200`. */
+    closeDelay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    placement: {
+        type: PropType<Placement>;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    placement: Placement;
+    openDelay: number;
+    closeDelay: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * Share a delay across a set of tooltips.
+ *
+ * Once one is open, moving to a neighbour shows its tooltip immediately. Without this, scanning a
+ * toolbar means waiting out the delay on every single button — the behaviour every desktop OS gets
+ * right and most web implementations miss.
+ *
+ * ```vue
+ * <TooltipProvider :delay="600">
+ *   <Toolbar />
+ * </TooltipProvider>
+ * ```
+ */
+declare const TooltipProvider: vue.DefineComponent<vue.ExtractPropTypes<{
+    /** Delay before the first tooltip in a group opens, in ms. Default `600`. */
+    delay: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    /** Delay before the first tooltip in a group opens, in ms. Default `600`. */
+    delay: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{}>, {
+    delay: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const Tooltip: vue.DefineComponent<vue.ExtractPropTypes<{
+    /** The tooltip text. Keep it short — it is read as one description. */
+    content: {
+        type: PropType<SlotContent>;
+        required: true;
+    };
+    placement: {
+        type: PropType<Placement>;
+        default: string;
+    };
+    /** Override the group delay, in ms. */
+    delay: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    /** Draw an arrow. Default `true`. */
+    arrow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    /** The tooltip text. Keep it short — it is read as one description. */
+    content: {
+        type: PropType<SlotContent>;
+        required: true;
+    };
+    placement: {
+        type: PropType<Placement>;
+        default: string;
+    };
+    /** Override the group delay, in ms. */
+    delay: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    /** Draw an arrow. Default `true`. */
+    arrow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    disabled: boolean;
+    delay: number;
+    placement: Placement;
+    arrow: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type DialogSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
+/**
+ * A modal dialog — the Vue counterpart of `@ansh-ui/react`'s `Dialog`.
+ *
+ * Not `<dialog showModal>`: the native element's top-layer behaviour is genuinely better, but its
+ * backdrop cannot be animated consistently, `::backdrop` inherits nothing, and closing behaviour
+ * differs enough across browsers to need working around anyway. The pieces the native element gives
+ * for free — focus trap, scroll lock, inert background, focus restore — are all here explicitly, via
+ * the same primitives `Popover` uses.
+ *
+ * `title` is a required prop rather than an optional slot. Every accessibility audit of a component
+ * library turns up unnamed dialogs, and the reliable fix is to make the name impossible to omit.
+ *
+ * React takes the body as `children` and the actions row as a `footer` prop; here they're the
+ * default slot and the `#footer` slot respectively — passing a render tree through a prop is
+ * idiomatic React and awkward Vue.
+ *
+ * ```vue
+ * <Dialog v-model:open="open" title="Delete project" description="This cannot be undone.">
+ *   <p>Body</p>
+ *   <template #footer>
+ *     <button @click="open = false">Cancel</button>
+ *   </template>
+ * </Dialog>
+ * ```
+ */
+declare const Dialog: vue.DefineComponent<vue.ExtractPropTypes<{
+    open: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    defaultOpen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** The dialog's accessible name. Required — a dialog announced as just "dialog" is useless. */
+    title: {
+        type: PropType<SlotContent>;
+        required: true;
+    };
+    /** Supporting text, wired to `aria-describedby`. */
+    description: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    size: {
+        type: PropType<DialogSize>;
+        default: string;
+    };
+    /** Show the close button. Default `true`. */
+    showClose: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Allow closing via scrim click and Escape. Default `true`. */
+    dismissable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Element to focus on open. Defaults to the first tabbable one. */
+    initialFocus: {
+        type: PropType<Ref<HTMLElement | null>>;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:open"[], "update:open", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    open: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    defaultOpen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** The dialog's accessible name. Required — a dialog announced as just "dialog" is useless. */
+    title: {
+        type: PropType<SlotContent>;
+        required: true;
+    };
+    /** Supporting text, wired to `aria-describedby`. */
+    description: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    size: {
+        type: PropType<DialogSize>;
+        default: string;
+    };
+    /** Show the close button. Default `true`. */
+    showClose: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Allow closing via scrim click and Escape. Default `true`. */
+    dismissable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Element to focus on open. Defaults to the first tabbable one. */
+    initialFocus: {
+        type: PropType<Ref<HTMLElement | null>>;
+        default: undefined;
+    };
+}>> & Readonly<{
+    "onUpdate:open"?: ((...args: any[]) => any) | undefined;
+}>, {
+    size: DialogSize;
+    description: SlotContent;
+    open: boolean;
+    defaultOpen: boolean;
+    showClose: boolean;
+    dismissable: boolean;
+    initialFocus: Ref<HTMLElement | null, HTMLElement | null>;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+/**
+ * A confirmation dialog — the Vue counterpart of `@ansh-ui/react`'s `AlertDialog`.
+ *
+ * `role="alertdialog"` and `aria-describedby` on the message, which makes a screen reader read the
+ * consequence immediately on open rather than waiting for the user to navigate to it. That is the
+ * entire difference from a regular dialog, and it matters precisely because these appear before
+ * irreversible actions.
+ *
+ * It is deliberately **not** dismissable by clicking the scrim: an accidental click outside should
+ * not silently cancel a decision the user was asked to make. Escape still works, because trapping
+ * someone in a dialog is worse. Neither is configurable — unlike `Dialog`, there is no
+ * `dismissable` prop, matching the React version exactly.
+ *
+ * Focus starts on **Cancel**, not Confirm. A keyboard user who hits Enter reflexively should not
+ * delete their account.
+ *
+ * React takes `onConfirm`/`onCancel` as function props (`onConfirm` can return a `Promise`, awaited
+ * by the caller before flipping `busy` back off). Function props aren't the Vue idiom for actions —
+ * every other component in this package emits an event for them instead (see `emits:
+ * ['update:modelValue', ...]` throughout `components/form`) — so this emits `confirm`/`cancel`
+ * rather than accepting callback props. The caller drives `busy` themselves either way.
+ */
+declare const AlertDialog: vue.DefineComponent<vue.ExtractPropTypes<{
+    open: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    defaultOpen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: {
+        type: PropType<SlotContent>;
+        required: true;
+    };
+    description: {
+        type: PropType<SlotContent>;
+        required: true;
+    };
+    /** Confirm button text. Default `'Confirm'`. */
+    confirmLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    cancelLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** Style the confirm action as destructive. */
+    destructive: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Disable the buttons while an async confirm runs. */
+    busy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("cancel" | "update:open" | "confirm")[], "cancel" | "update:open" | "confirm", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    open: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    defaultOpen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: {
+        type: PropType<SlotContent>;
+        required: true;
+    };
+    description: {
+        type: PropType<SlotContent>;
+        required: true;
+    };
+    /** Confirm button text. Default `'Confirm'`. */
+    confirmLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    cancelLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** Style the confirm action as destructive. */
+    destructive: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Disable the buttons while an async confirm runs. */
+    busy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onCancel?: ((...args: any[]) => any) | undefined;
+    "onUpdate:open"?: ((...args: any[]) => any) | undefined;
+    onConfirm?: ((...args: any[]) => any) | undefined;
+}>, {
+    open: boolean;
+    defaultOpen: boolean;
+    confirmLabel: string;
+    cancelLabel: string;
+    destructive: boolean;
+    busy: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+/** Layout helper for a dialog's action row. Right-aligned, reversed on narrow screens. */
+declare const DialogFooter: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type DrawerSide = 'left' | 'right' | 'top' | 'bottom';
+/**
+ * A panel that slides in from an edge — the Vue counterpart of `@ansh-ui/react`'s `Drawer`.
+ *
+ * Same accessibility contract as `Dialog` — it is a dialog, just positioned differently. The reason
+ * it exists separately is that the *content* pattern differs: drawers hold navigation, filters and
+ * detail views that stay open while the user works, so they support a non-modal mode where the page
+ * behind stays usable.
+ *
+ * On a phone a bottom drawer is the right shape for what would be a dialog on a desktop; that's a
+ * layout decision for the consumer, which is why `side` is a plain prop rather than a breakpoint
+ * rule baked in here.
+ *
+ * ```vue
+ * <Drawer v-model:open="open" side="left" title="Filters">
+ *   …
+ * </Drawer>
+ * ```
+ */
+declare const Drawer: vue.DefineComponent<vue.ExtractPropTypes<{
+    open: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    defaultOpen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Which edge it slides from. Default `'right'`. */
+    side: {
+        type: PropType<DrawerSide>;
+        default: string;
+    };
+    title: {
+        type: PropType<SlotContent>;
+        required: true;
+    };
+    description: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    /** Width for left/right, height for top/bottom. Default `'22rem'`. */
+    size: {
+        type: StringConstructor;
+        default: string;
+    };
+    showClose: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Block interaction behind and lock scroll. Default `true`. */
+    modal: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    dismissable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:open"[], "update:open", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    open: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    defaultOpen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Which edge it slides from. Default `'right'`. */
+    side: {
+        type: PropType<DrawerSide>;
+        default: string;
+    };
+    title: {
+        type: PropType<SlotContent>;
+        required: true;
+    };
+    description: {
+        type: PropType<SlotContent>;
+        default: undefined;
+    };
+    /** Width for left/right, height for top/bottom. Default `'22rem'`. */
+    size: {
+        type: StringConstructor;
+        default: string;
+    };
+    showClose: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Block interaction behind and lock scroll. Default `true`. */
+    modal: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    dismissable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:open"?: ((...args: any[]) => any) | undefined;
+}>, {
+    size: string;
+    description: SlotContent;
+    open: boolean;
+    side: DrawerSide;
+    defaultOpen: boolean;
+    modal: boolean;
+    showClose: boolean;
+    dismissable: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * Menus — dropdown and context. The Vue counterpart of `@ansh-ui/react`'s `DropdownMenu` /
+ * `ContextMenu`.
+ *
+ * Data-driven (`:items="[…]"`) rather than compound. Menus are almost always built from a
+ * configuration array anyway — permissions filter entries, a selection decides what's enabled — and
+ * expressing that as template children means `v-if` scattered through the tree, which breaks keyboard
+ * navigation indices in ways that are painful to debug.
+ *
+ * Follows the ARIA menu pattern, where **DOM focus moves to the item** (unlike a listbox, which
+ * keeps focus on the container). That's what makes Right/Left arrow submenu traversal work the way
+ * it does in every desktop application.
+ *
+ * Keyboard navigation (`Home`/`End`/arrows/typeahead) is implemented directly rather than through
+ * `useRovingFocus`: that primitive's arrow-key stepping doesn't skip disabled rows, while this menu's
+ * navigation must — landing the roving tab stop on a disabled item is the one behaviour the ARIA menu
+ * pattern explicitly forbids. The tabindex-per-row wiring below (`0` on the active row, `-1`
+ * elsewhere) is the same roving-tabindex shape `useRovingFocus` implements, just with the
+ * skip-disabled search this menu needs and the extra keys (`Enter`, `Escape`, `Tab`, typeahead,
+ * `ArrowRight`/`ArrowLeft` for submenus) a generic composite widget hook doesn't know about — ported
+ * directly from `@ansh-ui/react`'s own hand-rolled `move()`/`activate()`.
+ */
+interface MenuItemBase {
+    id?: string;
+    disabled?: boolean;
+}
+interface MenuAction extends MenuItemBase {
+    type?: 'item';
+    label: SlotContent;
+    icon?: SlotContent;
+    /** Display-only shortcut hint, e.g. `'⌘S'`. */
+    shortcut?: string;
+    /** Style as destructive, and mark it in the accessible name. */
+    danger?: boolean;
+    onSelect?: () => void;
+}
+interface MenuCheckbox extends MenuItemBase {
+    type: 'checkbox';
+    label: SlotContent;
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+    shortcut?: string;
+}
+interface MenuRadioGroup {
+    type: 'radio';
+    value: string;
+    onChange: (value: string) => void;
+    options: ReadonlyArray<{
+        value: string;
+        label: SlotContent;
+        disabled?: boolean;
+    }>;
+}
+interface MenuSubmenu extends MenuItemBase {
+    type: 'submenu';
+    label: SlotContent;
+    icon?: SlotContent;
+    items: readonly MenuEntry[];
+}
+type MenuEntry = MenuAction | MenuCheckbox | MenuRadioGroup | MenuSubmenu | {
+    type: 'separator';
+} | {
+    type: 'label';
+    label: SlotContent;
+};
+/**
+ * A dropdown menu.
+ *
+ * ```vue
+ * <DropdownMenu :items="[
+ *   { label: 'Edit', shortcut: '⌘E', onSelect: edit },
+ *   { type: 'separator' },
+ *   { label: 'Delete', danger: true, onSelect: remove },
+ * ]">
+ *   <IconButton label="Actions" />
+ * </DropdownMenu>
+ * ```
+ */
+declare const DropdownMenu: vue.DefineComponent<vue.ExtractPropTypes<{
+    items: {
+        type: PropType<readonly MenuEntry[]>;
+        required: true;
+    };
+    placement: {
+        type: PropType<Placement>;
+        default: string;
+    };
+    /** Accessible name for the menu itself. */
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    open: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    defaultOpen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:open"[], "update:open", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    items: {
+        type: PropType<readonly MenuEntry[]>;
+        required: true;
+    };
+    placement: {
+        type: PropType<Placement>;
+        default: string;
+    };
+    /** Accessible name for the menu itself. */
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    open: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    defaultOpen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:open"?: ((...args: any[]) => any) | undefined;
+}>, {
+    label: string;
+    open: boolean;
+    placement: Placement;
+    defaultOpen: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+/**
+ * A right-click menu.
+ *
+ * Also opens on the **context-menu key** and on Shift+F10, which is how keyboard users reach one —
+ * a right-click-only implementation is inaccessible, and it is the most commonly missed keyboard
+ * binding in the whole component set.
+ *
+ * Anchored to the pointer via a zero-size virtual rect, so the existing positioning code flips and
+ * shifts it near the viewport edges without needing a separate path.
+ */
+declare const ContextMenu: vue.DefineComponent<vue.ExtractPropTypes<{
+    items: {
+        type: PropType<readonly MenuEntry[]>;
+        required: true;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    items: {
+        type: PropType<readonly MenuEntry[]>;
+        required: true;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    label: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+export { AlertDialog, ContextMenu, Dialog, DialogFooter, type DialogSize, Drawer, type DrawerSide, DropdownMenu, HoverCard, type MenuAction, type MenuCheckbox, type MenuEntry, type MenuRadioGroup, type MenuSubmenu, Popover, PopoverContent, PopoverTrigger, Tooltip, TooltipProvider };