@radix-ng/primitives 0.51.0 → 1.0.0-beta.1

package/types/radix-ng-primitives-menu.d.ts

@@ -1,139 +1,624 @@
-import * as i0 from '@angular/core';
-import * as i1 from '@angular/cdk/menu';
-import { CdkMenuTrigger } from '@angular/cdk/menu';
-import { BooleanInput, NumberInput } from '@angular/cdk/coercion';
+import * as _angular_core from '@angular/core';
+import { Signal, ElementRef } from '@angular/core';
+import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
+import { BooleanInput, NumberInput } from '@radix-ng/primitives/core';
+import * as i1 from '@radix-ng/primitives/popper';
+import { RdxPopperContentWrapper, RdxPopperAnchorElement } from '@radix-ng/primitives/popper';
+import * as _radix_ng_primitives_menu from '@radix-ng/primitives/menu';
+import * as i2 from '@radix-ng/primitives/dismissable-layer';
+import * as i1$1 from '@radix-ng/primitives/portal';
+import { RdxPortalContainer } from '@radix-ng/primitives/portal';
+import * as i3 from '@radix-ng/primitives/focus-scope';
 
-declare class RdxMenuDirective {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxMenuDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxMenuDirective, "[RdxMenuRoot],[RdxMenuSub]", never, {}, {}, never, never, true, [{ directive: typeof i1.CdkMenu; inputs: {}; outputs: {}; }]>;
+type RdxMenuTransitionStatus = 'starting' | 'ending' | undefined;
+/**
+ * How focus moves into the popup when it opens.
+ * - `'first'` / `'last'` — focus and highlight the first / last item (keyboard opening).
+ * - `'popup'` — focus the popup container without highlighting any item (pointer opening, e.g. a
+ *   context menu opened by right click).
+ * - `false` — leave focus on the trigger.
+ */
+type RdxMenuAutoFocus = 'first' | 'last' | 'popup' | false;
+type RdxMenuAutoFocusInput = boolean | RdxMenuAutoFocus;
+type RdxMenuOrientation = 'horizontal' | 'vertical';
+interface RdxMenuRootContext {
+    isOpen: Signal<boolean>;
+    disabled: Signal<boolean>;
+    modal: Signal<boolean>;
+    loopFocus: Signal<boolean>;
+    highlightItemOnHover: Signal<boolean>;
+    orientation: Signal<RdxMenuOrientation>;
+    closeParentOnEsc: Signal<boolean>;
+    /** Whether the popup should focus its first item when it opens. */
+    autoFocus: Signal<RdxMenuAutoFocus>;
+    isSubmenu: Signal<boolean>;
+    hasTriggerInteractionHandler: Signal<boolean>;
+    trigger: Signal<HTMLElement | undefined>;
+    /** The popup element, once mounted. Used by submenu safe-polygon geometry. */
+    popupElement: Signal<HTMLElement | undefined>;
+    transitionStatus: Signal<RdxMenuTransitionStatus>;
+    close: () => void;
+    toggle: () => void;
+    show: (autoFocus?: RdxMenuAutoFocusInput) => void;
+    /** Open the menu without moving focus into the popup (used for menubar hover-switching). */
+    showWithoutAutoFocus: () => void;
+    registerTrigger: (el: HTMLElement) => () => void;
+    registerPopup: (el: HTMLElement) => () => void;
+    registerTransitionElement: (element: HTMLElement) => () => void;
+    registerPopupArrowNavigationHandler: (handler: (offset: 1 | -1) => boolean) => () => void;
+    registerTriggerInteractionHandler: (handler: RdxMenuTriggerInteractionHandler) => () => void;
+    markAsSubmenu: () => void;
+    closeParent: () => void;
+    handlePopupArrowNavigation: (offset: 1 | -1) => boolean;
+    handleTriggerInteraction: (interaction: RdxMenuTriggerInteraction) => boolean;
+}
+type RdxMenuTriggerInteraction = {
+    type: 'click';
+} | {
+    type: 'pointerenter';
+    event: PointerEvent;
+} | {
+    type: 'arrowdown';
+    event: Event;
+} | {
+    type: 'arrowup';
+    event: Event;
+} | {
+    type: 'arrowleft';
+    event: Event;
+} | {
+    type: 'arrowright';
+    event: Event;
+} | {
+    type: 'home';
+    event: Event;
+} | {
+    type: 'end';
+    event: Event;
+} | {
+    type: 'escape';
+    event: Event;
+};
+type RdxMenuTriggerInteractionHandler = (interaction: RdxMenuTriggerInteraction) => boolean;
+declare const injectRdxMenuRootContext: _radix_ng_primitives_core.InjectContext<RdxMenuRootContext>;
+declare const provideRdxMenuRootContext: (useFactory: () => RdxMenuRootContext) => _angular_core.Provider;
+/**
+ * Groups all parts of a menu.
+ */
+declare class RdxMenuRoot {
+    private readonly popper;
+    /** Shared open/close transition state machine (completes on the real animationend). */
+    private readonly transition;
+    private registeredTrigger;
+    private popupArrowNavigationHandler;
+    private triggerInteractionHandler;
+    private hasAppliedDefaultOpen;
+    /** Whether the menu is currently open. */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    /** Whether the menu is initially open. */
+    readonly defaultOpen: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether interactions with the menu are disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether the menu should block outside interactions. */
+    readonly modal: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether keyboard navigation wraps at list boundaries. */
+    readonly loopFocus: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether moving the pointer over items should highlight them. */
+    readonly highlightItemOnHover: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** The menu orientation. */
+    readonly orientation: _angular_core.InputSignal<RdxMenuOrientation>;
+    /** Whether pressing Escape inside a submenu closes the whole menu chain. */
+    readonly closeParentOnEsc: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Emits when the open state changes. */
+    readonly onOpenChange: _angular_core.OutputEmitterRef<boolean>;
+    /** Emits when the open/close CSS transition or animation finishes. */
+    readonly onOpenChangeComplete: _angular_core.OutputEmitterRef<boolean>;
+    readonly trigger: _angular_core.WritableSignal<HTMLElement | undefined>;
+    readonly popupElement: _angular_core.WritableSignal<HTMLElement | undefined>;
+    readonly transitionStatus: Signal<_radix_ng_primitives_core.RdxTransitionStatus>;
+    /** Whether the popup grabs focus when it opens. Set false for menubar hover-switching. */
+    readonly autoFocus: _angular_core.WritableSignal<RdxMenuAutoFocus>;
+    readonly isSubmenu: _angular_core.WritableSignal<boolean>;
+    readonly hasTriggerInteractionHandler: _angular_core.WritableSignal<boolean>;
+    readonly state: Signal<"open" | "closed">;
+    constructor();
+    show(autoFocus?: RdxMenuAutoFocusInput): void;
+    close(): void;
+    toggle(): void;
+    registerTrigger(el: HTMLElement): () => void;
+    registerPopup(el: HTMLElement): () => void;
+    registerTransitionElement(element: HTMLElement): () => void;
+    registerPopupArrowNavigationHandler(handler: (offset: 1 | -1) => boolean): () => void;
+    handlePopupArrowNavigation(offset: 1 | -1): boolean;
+    registerTriggerInteractionHandler(handler: RdxMenuTriggerInteractionHandler): () => void;
+    handleTriggerInteraction(interaction: RdxMenuTriggerInteraction): boolean;
+    markAsSubmenu(): void;
+    closeParent(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuRoot, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuRoot, "[rdxMenuRoot],[rdxMenuSubmenuRoot]", ["rdxMenuRoot"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "loopFocus": { "alias": "loopFocus"; "required": false; "isSignal": true; }; "highlightItemOnHover": { "alias": "highlightItemOnHover"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "closeParentOnEsc": { "alias": "closeParentOnEsc"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "onOpenChange": "onOpenChange"; "onOpenChangeComplete": "onOpenChangeComplete"; }, never, never, true, [{ directive: typeof i1.RdxPopper; inputs: {}; outputs: {}; }]>;
 }
 
-type CheckedState = boolean | 'indeterminate';
-declare function isIndeterminate(checked?: CheckedState): checked is 'indeterminate';
-declare function getCheckedState(checked: CheckedState): "indeterminate" | "checked" | "unchecked";
-
-declare class RdxMenuItemCheckboxDirective {
-    private readonly cdkMenuItemCheckbox;
-    readonly disabled: i0.InputSignalWithTransform<boolean, BooleanInput>;
-    readonly checked: i0.InputSignal<boolean | "indeterminate">;
-    readonly onCheckedChange: i0.OutputRef<void>;
-    protected readonly disabledState: i0.Signal<i0.InputSignalWithTransform<boolean, BooleanInput>>;
-    protected readonly highlightedState: i0.Signal<boolean>;
-    private readonly isFocused;
+/**
+ * A button that opens the menu.
+ */
+declare class RdxMenuTrigger {
+    protected readonly rootContext: _radix_ng_primitives_menu.RdxMenuRootContext;
+    private readonly elementRef;
+    private readonly destroyRef;
+    private readonly dismissableLayersContext;
+    private openTimer;
+    private closeTimer;
+    /** Whether this trigger should be treated as a native button. Auto-detected for `<button>`. */
+    readonly nativeButton: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether this trigger is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether hovering the trigger opens the menu. */
+    readonly openOnHover: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Delay before hover opens the menu, in milliseconds. */
+    readonly delay: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
+    /** Delay before hover leave closes the menu, in milliseconds. */
+    readonly closeDelay: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
+    protected readonly nativeButtonState: _angular_core.Signal<boolean>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
     constructor();
-    onFocus(): void;
-    onBlur(): void;
-    onPointerMove(event: PointerEvent): void;
-    protected readonly isIndeterminate: typeof isIndeterminate;
-    protected readonly getCheckedState: typeof getCheckedState;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxMenuItemCheckboxDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxMenuItemCheckboxDirective, "[RdxMenuItemCheckbox]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; }, { "onCheckedChange": "onCheckedChange"; }, never, never, true, [{ directive: typeof i1.CdkMenuItemCheckbox; inputs: {}; outputs: { "cdkMenuItemTriggered": "menuItemTriggered"; }; }]>;
+    protected handleClick(): void;
+    protected handleArrowDown(event: Event): void;
+    protected handleArrowUp(event: Event): void;
+    protected handleArrowLeft(event: Event): void;
+    protected handleArrowRight(event: Event): void;
+    protected handleHome(event: Event): void;
+    protected handleEnd(event: Event): void;
+    protected handleEscape(event: Event): void;
+    protected handleKeyboardToggle(event: Event): void;
+    protected handlePointerEnter(event: PointerEvent): void;
+    protected handlePointerLeave(event: PointerEvent): void;
+    private clearOpenTimer;
+    private clearCloseTimer;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuTrigger, "[rdxMenuTrigger]", ["rdxMenuTrigger"], { "nativeButton": { "alias": "nativeButton"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "openOnHover": { "alias": "openOnHover"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.RdxPopperAnchor; inputs: {}; outputs: {}; }]>;
 }
 
-declare class RdxMenuItemRadioDirective {
-    private readonly cdkMenuItemRadio;
-    readonly disabled: i0.InputSignalWithTransform<boolean, BooleanInput>;
-    readonly checked: i0.InputSignalWithTransform<boolean, BooleanInput>;
-    readonly onValueChange: i0.OutputRef<void>;
-    protected readonly disabledState: i0.Signal<boolean>;
-    protected readonly highlightedState: i0.Signal<boolean>;
+/**
+ * An item inside a parent menu that opens a nested submenu.
+ *
+ * Place this inside `ng-container rdxMenuRoot` that wraps both the trigger
+ * and the submenu positioner. The inner root provides the submenu context;
+ * the outer popup discovers this element via `[rdxMenuSubTrigger]` in its
+ * ITEM_SELECTOR and includes it in keyboard navigation.
+ */
+declare class RdxMenuSubTrigger {
+    protected readonly submenuContext: _radix_ng_primitives_menu.RdxMenuRootContext;
+    private readonly submenuRoot;
+    private readonly elementRef;
+    private readonly destroyRef;
+    private readonly isBrowser;
     private readonly isFocused;
+    private openTimer;
+    private closeTimer;
+    /** Cursor position from the last pointer move over the trigger (safe-polygon apex). */
+    private lastPointer;
+    /** Whether the current open was initiated by hover (vs keyboard / click). */
+    private openedByHover;
+    /** Whether this trigger (and therefore the submenu) is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether this trigger should be treated as a native button. Auto-detected for `<button>`. */
+    readonly nativeButton: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether hovering the trigger opens the submenu. */
+    readonly openOnHover: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Delay before hover opens the submenu, in milliseconds. */
+    readonly delay: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
+    /** Delay before a pending hover close runs, in milliseconds. */
+    readonly closeDelay: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
+    /** Explicit typeahead label. When set, overrides textContent for character search. */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /** Highlighted when focused OR while the submenu is open. */
+    protected readonly highlighted: _angular_core.Signal<boolean>;
+    protected readonly nativeButtonState: _angular_core.Signal<boolean>;
     constructor();
-    onFocus(): void;
-    onBlur(): void;
-    onPointerMove(event: PointerEvent): void;
-    protected readonly getCheckedState: typeof getCheckedState;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxMenuItemRadioDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxMenuItemRadioDirective, "[RdxMenuItemRadio]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; }, { "onValueChange": "onValueChange"; }, never, never, true, [{ directive: typeof i1.CdkMenuItemRadio; inputs: {}; outputs: { "cdkMenuItemTriggered": "menuItemTriggered"; }; }]>;
+    private scheduleClose;
+    protected onFocus(): void;
+    protected onBlur(): void;
+    protected onClick(): void;
+    protected onArrowRight(event: Event): void;
+    protected onPointerMove(event: PointerEvent): void;
+    protected onPointerLeave(): void;
+    protected clearHighlight(): void;
+    private closeSiblingSubmenus;
+    private clearSiblingHighlights;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuSubTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuSubTrigger, "[rdxMenuSubTrigger]", ["rdxMenuSubTrigger"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "nativeButton": { "alias": "nativeButton"; "required": false; "isSignal": true; }; "openOnHover": { "alias": "openOnHover"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.RdxPopperAnchor; inputs: {}; outputs: {}; }, { directive: typeof i2.RdxDismissableLayerBranch; inputs: {}; outputs: {}; }]>;
 }
 
-declare class RdxMenuItemIndicatorDirective {
-    private readonly menuItemRadio;
-    private readonly menuCheckboxItem;
-    get isChecked(): boolean;
-    protected readonly getCheckedState: typeof getCheckedState;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxMenuItemIndicatorDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxMenuItemIndicatorDirective, "[RdxMenuItemIndicator]", never, {}, {}, never, never, true, never>;
+/**
+ * Moves the menu to a different part of the DOM.
+ * Applied on ng-template — no host bindings (ng-template is not a real DOM node).
+ */
+declare class RdxMenuPortal {
+    /**
+     * Optional container to portal the content into. Defaults to `document.body`.
+     */
+    readonly container: _angular_core.InputSignal<RdxPortalContainer | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuPortal, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuPortal, "[rdxMenuPortal]", ["rdxMenuPortal"], { "container": { "alias": "container"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.RdxPortal; inputs: { "container": "container"; }; outputs: {}; }]>;
+}
+
+/**
+ * Positions the menu against its trigger.
+ */
+declare class RdxMenuPositioner {
+    protected readonly rootContext: _radix_ng_primitives_menu.RdxMenuRootContext;
+    protected readonly wrapper: RdxPopperContentWrapper;
+    /**
+     * An element to position the popup against. Defaults to the trigger.
+     */
+    readonly anchor: _angular_core.InputSignal<RdxPopperAnchorElement>;
+    /**
+     * The preferred side of the trigger to render against when open.
+     */
+    readonly side: _angular_core.InputSignal<"top" | "right" | "bottom" | "left">;
+    /**
+     * Distance between the trigger and the popup in pixels.
+     */
+    readonly sideOffset: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * How to align the popup relative to the specified side.
+     */
+    readonly align: _angular_core.InputSignal<"end" | "start" | "center">;
+    /**
+     * An offset in pixels from the `start` or `end` alignment options.
+     */
+    readonly alignOffset: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * Minimum distance to maintain between the arrow and the edges of the popup.
+     */
+    readonly arrowPadding: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * Whether to override side and alignment preferences to prevent collisions.
+     */
+    readonly avoidCollisions: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The element used as the collision boundary.
+     */
+    readonly collisionBoundary: _angular_core.InputSignal<ElementRef<HTMLElement> | ElementRef<HTMLElement>[] | undefined>;
+    /**
+     * Distance in pixels from the boundary edges where collision detection should occur.
+     */
+    readonly collisionPadding: _angular_core.InputSignal<number | Partial<Record<"top" | "right" | "bottom" | "left", number>>>;
+    /**
+     * The sticky behavior on the alignment axis.
+     */
+    readonly sticky: _angular_core.InputSignal<"always" | "partial">;
+    /**
+     * Whether to hide the popup when the trigger becomes fully occluded.
+     */
+    readonly hideWhenDetached: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The CSS position strategy used by Floating UI.
+     */
+    readonly positionStrategy: _angular_core.InputSignal<"fixed" | "absolute">;
+    /**
+     * Whether to update position on every animation frame.
+     */
+    readonly updatePositionStrategy: _angular_core.InputSignal<"always" | "optimized">;
+    /**
+     * Emits when the popup has been placed.
+     */
+    readonly placed: _angular_core.OutputRef<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuPositioner, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuPositioner, "[rdxMenuPositioner]", ["rdxMenuPositioner"], { "anchor": { "alias": "anchor"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "alignOffset": { "alias": "alignOffset"; "required": false; "isSignal": true; }; "arrowPadding": { "alias": "arrowPadding"; "required": false; "isSignal": true; }; "avoidCollisions": { "alias": "avoidCollisions"; "required": false; "isSignal": true; }; "collisionBoundary": { "alias": "collisionBoundary"; "required": false; "isSignal": true; }; "collisionPadding": { "alias": "collisionPadding"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "hideWhenDetached": { "alias": "hideWhenDetached"; "required": false; "isSignal": true; }; "positionStrategy": { "alias": "positionStrategy"; "required": false; "isSignal": true; }; "updatePositionStrategy": { "alias": "updatePositionStrategy"; "required": false; "isSignal": true; }; }, { "placed": "placed"; }, never, never, true, [{ directive: typeof i1.RdxPopperContentWrapper; inputs: { "anchor": "anchor"; "side": "side"; "sideOffset": "sideOffset"; "align": "align"; "alignOffset": "alignOffset"; "arrowPadding": "arrowPadding"; "avoidCollisions": "avoidCollisions"; "collisionBoundary": "collisionBoundary"; "collisionPadding": "collisionPadding"; "sticky": "sticky"; "hideWhenDetached": "hideWhenDetached"; "positionStrategy": "positionStrategy"; "updatePositionStrategy": "updatePositionStrategy"; }; outputs: {}; }]>;
 }
 
-type RdxMenuAlign = 'start' | 'center' | 'end';
-type RdxMenuSide = 'top' | 'right' | 'bottom' | 'left';
-declare class RdxMenuTriggerDirective {
-    protected readonly cdkTrigger: CdkMenuTrigger;
-    readonly menuTriggerFor: i0.InputSignal<unknown>;
+/**
+ * A container for the menu contents.
+ */
+declare class RdxMenuPopup {
+    protected readonly rootContext: _radix_ng_primitives_menu.RdxMenuRootContext;
+    private readonly dismissableLayer;
+    private readonly focusScope;
+    private readonly wrapper;
+    private readonly elementRef;
+    private readonly dismissableLayersContext;
+    private search;
+    private searchTimer;
+    protected readonly align: _angular_core.Signal<"end" | "start" | "center" | undefined>;
+    protected readonly side: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
     /**
-     * @description The preferred side of the trigger to render against when open. Will be reversed when collisions occur and avoidCollisions is enabled.
+     * Event handler called when the escape key is pressed. Can be prevented.
      */
-    readonly side: i0.InputSignal<RdxMenuSide | undefined>;
-    readonly align: i0.InputSignal<RdxMenuAlign | undefined>;
+    readonly escapeKeyDown: _angular_core.OutputRef<KeyboardEvent>;
     /**
-     * @description The distance in pixels from the trigger.
+     * Event handler called when a pointerdown event happens outside of the popup. Can be prevented.
      */
-    readonly sideOffset: i0.InputSignalWithTransform<number, NumberInput>;
+    readonly pointerDownOutside: _angular_core.OutputRef<PointerEvent>;
     /**
-     * @description An offset in pixels from the "start" or "end" alignment options.
+     * Event handler called when focus moves outside of the popup. Can be prevented.
      */
-    readonly alignOffset: i0.InputSignalWithTransform<number, NumberInput>;
-    readonly disabled: i0.InputSignalWithTransform<boolean, BooleanInput>;
-    private enablePositions;
-    private readonly positions;
-    private computePositions;
+    readonly focusOutside: _angular_core.OutputRef<FocusEvent>;
+    /**
+     * Event handler called when an interaction happens outside of the popup. Can be prevented.
+     */
+    readonly interactOutside: _angular_core.OutputRef<PointerEvent | FocusEvent>;
+    /**
+     * Event handler called before focus moves into the popup. Can be prevented.
+     */
+    readonly openAutoFocus: _angular_core.OutputRef<Event>;
+    /**
+     * Event handler called before focus returns after the popup is removed. Can be prevented.
+     */
+    readonly closeAutoFocus: _angular_core.OutputRef<Event>;
     constructor();
-    /** @ignore */
-    onPointerDown($event: Event): void;
-    private onMenuPositionEffect;
-    private setMenuPositions;
-    private fireNgOnChanges;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxMenuTriggerDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxMenuTriggerDirective, "[RdxMenuTrigger]", never, { "menuTriggerFor": { "alias": "menuTriggerFor"; "required": true; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "alignOffset": { "alias": "alignOffset"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.CdkMenuTrigger; inputs: { "cdkMenuTriggerFor": "menuTriggerFor"; "cdkMenuPosition": "menuPosition"; }; outputs: {}; }]>;
+    protected handleCloseParent(event: Event): void;
+    protected handleKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuPopup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuPopup, "[rdxMenuPopup]", ["rdxMenuPopup"], {}, { "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; "focusOutside": "focusOutside"; "interactOutside": "interactOutside"; "openAutoFocus": "openAutoFocus"; "closeAutoFocus": "closeAutoFocus"; }, never, never, true, [{ directive: typeof i1.RdxPopperContent; inputs: {}; outputs: {}; }, { directive: typeof i2.RdxDismissableLayer; inputs: {}; outputs: {}; }, { directive: typeof i3.RdxFocusScope; inputs: {}; outputs: {}; }]>;
 }
 
-declare class RdxMenuGroupDirective {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxMenuGroupDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxMenuGroupDirective, "[RdxMenuGroup]", never, {}, {}, never, never, true, [{ directive: typeof i1.CdkMenuGroup; inputs: {}; outputs: {}; }]>;
+/**
+ * A viewport that smoothly animates the popup size when its content changes
+ * (e.g. switching menubar menus of different sizes, or expanding a section).
+ *
+ * It measures its content with a `ResizeObserver` and exposes the current size
+ * as `--popup-width` / `--popup-height` CSS variables on the host. Drive the
+ * animation from the consumer side, for example:
+ *
+ * ```css
+ * [rdxMenuPopup] {
+ *     width: var(--popup-width);
+ *     height: var(--popup-height);
+ *     transition: width 200ms, height 200ms;
+ * }
+ * ```
+ *
+ * `data-transitioning` is present while a size change is in flight.
+ */
+declare class RdxMenuViewport {
+    private readonly elementRef;
+    private readonly destroyRef;
+    private observer;
+    private transitionTimer;
+    protected readonly width: _angular_core.WritableSignal<number | undefined>;
+    protected readonly height: _angular_core.WritableSignal<number | undefined>;
+    protected readonly transitioning: _angular_core.WritableSignal<boolean>;
+    constructor();
+    private markTransitioning;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuViewport, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuViewport, "[rdxMenuViewport]", ["rdxMenuViewport"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * An optional overlay rendered behind the menu popup.
+ * Style it with `position: fixed; inset: 0` and use `data-open` / `data-closed`
+ * for CSS animations.
+ */
+declare class RdxMenuBackdrop {
+    protected readonly rootContext: _radix_ng_primitives_menu.RdxMenuRootContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuBackdrop, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuBackdrop, "[rdxMenuBackdrop]", ["rdxMenuBackdrop"], {}, {}, never, never, true, never>;
 }
 
-declare class RdxMenuRadioGroupDirective {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxMenuRadioGroupDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxMenuRadioGroupDirective, "[RdxMenuRadioGroup]", never, {}, {}, never, never, true, [{ directive: typeof i1.CdkMenuGroup; inputs: {}; outputs: {}; }]>;
+/**
+ * An optional visual arrow connecting the popup to its trigger.
+ * Place it inside `rdxMenuPopup`. Positioning is handled by the shared Popper Arrow primitive.
+ */
+declare class RdxMenuArrow {
+    protected readonly rootContext: _radix_ng_primitives_menu.RdxMenuRootContext;
+    private readonly wrapper;
+    protected readonly side: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    protected readonly align: _angular_core.Signal<"end" | "start" | "center" | undefined>;
+    protected readonly uncentered: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuArrow, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuArrow, "[rdxMenuArrow]", ["rdxMenuArrow"], {}, {}, never, never, true, [{ directive: typeof i1.RdxPopperArrow; inputs: {}; outputs: {}; }]>;
 }
 
-declare class RdxMenuItemDirective {
-    private readonly cdkMenuItem;
-    readonly disabled: i0.InputSignalWithTransform<boolean, BooleanInput>;
-    readonly onSelect: i0.OutputRef<void>;
+/**
+ * An individual menu item.
+ */
+declare class RdxMenuItem {
+    private readonly rootContext;
+    private readonly elementRef;
     private readonly isFocused;
-    protected readonly disabledState: i0.Signal<boolean>;
-    protected readonly isOpenState: i0.WritableSignal<boolean>;
-    protected readonly highlightedState: i0.Signal<boolean>;
-    constructor();
+    /** Whether this item is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether selecting this item closes the menu. */
+    readonly closeOnClick: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Explicit typeahead label. When set, overrides textContent for character search. */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /** Emits when the item is selected. */
+    readonly onSelect: _angular_core.OutputEmitterRef<void>;
+    protected readonly highlighted: _angular_core.Signal<boolean>;
+    onFocus(): void;
+    onBlur(): void;
+    onPointerMove(event: PointerEvent): void;
+    onPointerLeave(event: PointerEvent): void;
+    onItemClick(): void;
+    protected onActivate(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuItem, "[rdxMenuItem]", ["rdxMenuItem"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "closeOnClick": { "alias": "closeOnClick"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "onSelect": "onSelect"; }, never, never, true, never>;
+}
+
+/**
+ * A menu item that renders as a link.
+ */
+declare class RdxMenuLinkItem {
+    private readonly rootContext;
+    private readonly elementRef;
+    private readonly isFocused;
+    /** Whether this item is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether selecting this item closes the menu. Defaults to false — links navigate by default. */
+    readonly closeOnClick: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Explicit typeahead label. When set, overrides textContent for character search. */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /** Emits when the item is selected. */
+    readonly onSelect: _angular_core.OutputEmitterRef<void>;
+    protected readonly highlighted: _angular_core.Signal<boolean>;
     onFocus(): void;
     onBlur(): void;
     onPointerMove(event: PointerEvent): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxMenuItemDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxMenuItemDirective, "[RdxMenuItem]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "onSelect": "onSelect"; }, never, never, true, [{ directive: typeof i1.CdkMenuItem; inputs: {}; outputs: { "cdkMenuItemTriggered": "menuItemTriggered"; }; }]>;
+    onPointerLeave(event: PointerEvent): void;
+    onItemClick(event: MouseEvent): void;
+    protected onActivate(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuLinkItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuLinkItem, "a[rdxMenuLinkItem]", ["rdxMenuLinkItem"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "closeOnClick": { "alias": "closeOnClick"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "onSelect": "onSelect"; }, never, never, true, never>;
+}
+
+/**
+ * Groups related menu items together.
+ */
+declare class RdxMenuGroup {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuGroup, "[rdxMenuGroup]", ["rdxMenuGroup"], {}, {}, never, never, true, never>;
 }
 
-declare class RdxMenuSeparatorDirective {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxMenuSeparatorDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxMenuSeparatorDirective, "[RdxMenuSeparator]", never, {}, {}, never, never, true, never>;
+/**
+ * A label for a menu group.
+ */
+declare class RdxMenuGroupLabel {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuGroupLabel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuGroupLabel, "[rdxMenuGroupLabel]", ["rdxMenuGroupLabel"], {}, {}, never, never, true, never>;
 }
 
-declare class RdxMenuContentDirective {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxMenuContentDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxMenuContentDirective, "[RdxMenuContent]", never, {}, {}, never, never, true, [{ directive: typeof i1.CdkMenu; inputs: {}; outputs: {}; }]>;
+/**
+ * A visual separator between groups of menu items.
+ */
+declare class RdxMenuSeparator {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuSeparator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuSeparator, "[rdxMenuSeparator]", ["rdxMenuSeparator"], {}, {}, never, never, true, never>;
+}
+
+type CheckedState = boolean | 'indeterminate';
+declare function isIndeterminate(checked?: CheckedState): checked is 'indeterminate';
+declare function getCheckedState(checked: CheckedState): 'checked' | 'unchecked' | 'indeterminate';
+
+interface RdxMenuCheckboxItemContext {
+    checked: Signal<CheckedState>;
+}
+declare const injectRdxMenuCheckboxItemContext: _radix_ng_primitives_core.InjectContext<RdxMenuCheckboxItemContext>;
+declare const provideRdxMenuCheckboxItemContext: (useFactory: () => RdxMenuCheckboxItemContext) => _angular_core.Provider;
+/**
+ * A menu item that can be checked or unchecked.
+ */
+declare class RdxMenuCheckboxItem {
+    private readonly rootContext;
+    private readonly elementRef;
+    private readonly isFocused;
+    /** Whether this item is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether toggling closes the menu. Defaults to false — checkbox items stay open. */
+    readonly closeOnClick: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Explicit typeahead label. When set, overrides textContent for character search. */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /** The checked state of the item. */
+    readonly checked: _angular_core.ModelSignal<CheckedState>;
+    /** Emits when the checked state changes. */
+    readonly onCheckedChange: _angular_core.OutputEmitterRef<CheckedState>;
+    protected readonly highlighted: Signal<boolean>;
+    protected readonly isIndeterminate: typeof isIndeterminate;
+    protected readonly getCheckedState: typeof getCheckedState;
+    onFocus(): void;
+    onBlur(): void;
+    onPointerMove(event: PointerEvent): void;
+    onPointerLeave(event: PointerEvent): void;
+    onItemClick(): void;
+    protected onActivate(event: Event): void;
+    private toggleChecked;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuCheckboxItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuCheckboxItem, "[rdxMenuCheckboxItem]", ["rdxMenuCheckboxItem"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "closeOnClick": { "alias": "closeOnClick"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "onCheckedChange": "onCheckedChange"; }, never, never, true, never>;
+}
+
+/**
+ * Renders when the parent checkbox item is checked or indeterminate.
+ * Set `keepMounted` to keep the element in the DOM when unchecked (enables CSS animations).
+ */
+declare class RdxMenuCheckboxItemIndicator {
+    private readonly itemContext;
+    /** Keep the indicator in the DOM when unchecked so CSS exit animations can play. */
+    readonly keepMounted: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly dataState: _angular_core.Signal<"indeterminate" | "checked" | "unchecked">;
+    protected readonly isVisible: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuCheckboxItemIndicator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuCheckboxItemIndicator, "[rdxMenuCheckboxItemIndicator]", ["rdxMenuCheckboxItemIndicator"], { "keepMounted": { "alias": "keepMounted"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface RdxMenuRadioGroupContext {
+    value: Signal<string | undefined>;
+    selectValue: (value: string) => void;
+}
+declare const injectRdxMenuRadioGroupContext: _radix_ng_primitives_core.InjectContext<RdxMenuRadioGroupContext>;
+declare const provideRdxMenuRadioGroupContext: (useFactory: () => RdxMenuRadioGroupContext) => _angular_core.Provider;
+/**
+ * Groups radio items in a menu.
+ */
+declare class RdxMenuRadioGroup {
+    /**
+     * The currently selected value.
+     */
+    readonly value: _angular_core.ModelSignal<string | undefined>;
+    /**
+     * Emits when the selected value changes.
+     */
+    readonly onValueChange: _angular_core.OutputEmitterRef<string>;
+    selectValue(newValue: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuRadioGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuRadioGroup, "[rdxMenuRadioGroup]", ["rdxMenuRadioGroup"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onValueChange": "onValueChange"; }, never, never, true, never>;
+}
+
+interface RdxMenuRadioItemContext {
+    checked: Signal<boolean>;
+}
+declare const injectRdxMenuRadioItemContext: _radix_ng_primitives_core.InjectContext<RdxMenuRadioItemContext>;
+declare const provideRdxMenuRadioItemContext: (useFactory: () => RdxMenuRadioItemContext) => _angular_core.Provider;
+/**
+ * A radio item within a menu radio group.
+ */
+declare class RdxMenuRadioItem {
+    private readonly rootContext;
+    private readonly radioGroupContext;
+    private readonly elementRef;
+    private readonly isFocused;
+    /** The value of this radio item. */
+    readonly value: _angular_core.InputSignal<string>;
+    /** Whether this item is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether selecting closes the menu. Defaults to false — radio items stay open. */
+    readonly closeOnClick: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Explicit typeahead label. When set, overrides textContent for character search. */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /** Emits when this item is selected. */
+    readonly onSelect: _angular_core.OutputEmitterRef<string>;
+    readonly checked: Signal<boolean>;
+    protected readonly highlighted: Signal<boolean>;
+    protected readonly getCheckedState: typeof getCheckedState;
+    onFocus(): void;
+    onBlur(): void;
+    onPointerMove(event: PointerEvent): void;
+    onPointerLeave(event: PointerEvent): void;
+    onItemClick(): void;
+    protected onActivate(event: Event): void;
+    private selectItem;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuRadioItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuRadioItem, "[rdxMenuRadioItem]", ["rdxMenuRadioItem"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "closeOnClick": { "alias": "closeOnClick"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "onSelect": "onSelect"; }, never, never, true, never>;
 }
 
-declare class RdxMenuLabelDirective {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxMenuLabelDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxMenuLabelDirective, "[RdxMenuLabel]", never, {}, {}, never, never, true, never>;
+/**
+ * Renders when the parent radio item is selected.
+ * Set `keepMounted` to keep the element in the DOM when unselected (enables CSS animations).
+ */
+declare class RdxMenuRadioItemIndicator {
+    private readonly itemContext;
+    /** Keep the indicator in the DOM when unselected so CSS exit animations can play. */
+    readonly keepMounted: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly dataState: _angular_core.Signal<"indeterminate" | "checked" | "unchecked">;
+    protected readonly isVisible: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuRadioItemIndicator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuRadioItemIndicator, "[rdxMenuRadioItemIndicator]", ["rdxMenuRadioItemIndicator"], { "keepMounted": { "alias": "keepMounted"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class RdxMenuModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxMenuModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxMenuModule, never, [typeof RdxMenuDirective, typeof RdxMenuItemCheckboxDirective, typeof RdxMenuItemRadioDirective, typeof RdxMenuItemIndicatorDirective, typeof RdxMenuTriggerDirective, typeof RdxMenuGroupDirective, typeof RdxMenuRadioGroupDirective, typeof RdxMenuItemDirective, typeof RdxMenuSeparatorDirective, typeof RdxMenuContentDirective, typeof RdxMenuLabelDirective], [typeof RdxMenuDirective, typeof RdxMenuItemCheckboxDirective, typeof RdxMenuItemRadioDirective, typeof RdxMenuItemIndicatorDirective, typeof RdxMenuTriggerDirective, typeof RdxMenuGroupDirective, typeof RdxMenuRadioGroupDirective, typeof RdxMenuItemDirective, typeof RdxMenuSeparatorDirective, typeof RdxMenuContentDirective, typeof RdxMenuLabelDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<RdxMenuModule>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxMenuModule, never, [typeof RdxMenuRoot, typeof RdxMenuTrigger, typeof RdxMenuSubTrigger, typeof RdxMenuPortal, typeof RdxMenuPositioner, typeof RdxMenuPopup, typeof RdxMenuViewport, typeof RdxMenuBackdrop, typeof RdxMenuArrow, typeof RdxMenuItem, typeof RdxMenuLinkItem, typeof RdxMenuGroup, typeof RdxMenuGroupLabel, typeof RdxMenuSeparator, typeof RdxMenuCheckboxItem, typeof RdxMenuCheckboxItemIndicator, typeof RdxMenuRadioGroup, typeof RdxMenuRadioItem, typeof RdxMenuRadioItemIndicator], [typeof RdxMenuRoot, typeof RdxMenuTrigger, typeof RdxMenuSubTrigger, typeof RdxMenuPortal, typeof RdxMenuPositioner, typeof RdxMenuPopup, typeof RdxMenuViewport, typeof RdxMenuBackdrop, typeof RdxMenuArrow, typeof RdxMenuItem, typeof RdxMenuLinkItem, typeof RdxMenuGroup, typeof RdxMenuGroupLabel, typeof RdxMenuSeparator, typeof RdxMenuCheckboxItem, typeof RdxMenuCheckboxItemIndicator, typeof RdxMenuRadioGroup, typeof RdxMenuRadioItem, typeof RdxMenuRadioItemIndicator]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<RdxMenuModule>;
 }
 
-export { RdxMenuContentDirective, RdxMenuDirective, RdxMenuGroupDirective, RdxMenuItemCheckboxDirective, RdxMenuItemDirective, RdxMenuItemIndicatorDirective, RdxMenuItemRadioDirective, RdxMenuLabelDirective, RdxMenuModule, RdxMenuRadioGroupDirective, RdxMenuSeparatorDirective, RdxMenuTriggerDirective };
-export type { RdxMenuAlign, RdxMenuSide };
+export { RdxMenuArrow, RdxMenuBackdrop, RdxMenuCheckboxItem, RdxMenuCheckboxItemIndicator, RdxMenuGroup, RdxMenuGroupLabel, RdxMenuItem, RdxMenuLinkItem, RdxMenuModule, RdxMenuPopup, RdxMenuPortal, RdxMenuPositioner, RdxMenuRadioGroup, RdxMenuRadioItem, RdxMenuRadioItemIndicator, RdxMenuRoot, RdxMenuSeparator, RdxMenuSubTrigger, RdxMenuTrigger, RdxMenuViewport, getCheckedState, injectRdxMenuCheckboxItemContext, injectRdxMenuRadioGroupContext, injectRdxMenuRadioItemContext, injectRdxMenuRootContext, isIndeterminate, provideRdxMenuCheckboxItemContext, provideRdxMenuRadioGroupContext, provideRdxMenuRadioItemContext, provideRdxMenuRootContext };
+export type { CheckedState, RdxMenuAutoFocus, RdxMenuAutoFocusInput, RdxMenuCheckboxItemContext, RdxMenuOrientation, RdxMenuRadioGroupContext, RdxMenuRadioItemContext, RdxMenuRootContext, RdxMenuTransitionStatus, RdxMenuTriggerInteraction, RdxMenuTriggerInteractionHandler };