@radix-ng/primitives 1.0.0-beta.4 → 1.0.1

package/types/radix-ng-primitives-floating-focus-manager.d.ts

@@ -1,6 +1,6 @@
 import * as _angular_core from '@angular/core';
-import { InjectionToken, Provider } from '@angular/core';
-import { BooleanInput } from '@radix-ng/primitives/core';
+import { InjectionToken, Provider, Signal } from '@angular/core';
+import { RdxFloatingTree, BooleanInput } from '@radix-ng/primitives/core';
 import * as i1 from '@radix-ng/primitives/focus-scope';
 
 /**
@@ -9,25 +9,25 @@ import * as i1 from '@radix-ng/primitives/focus-scope';
  * (Base UI keys `preferPreviousFocus = openInteractionType == null` off exactly this).
  */
 type RdxInteractionType = 'mouse' | 'touch' | 'pen' | 'keyboard' | '' | null;
-/** A focus target: an element, a getter, or `null`. */
-type RdxFocusTarget = HTMLElement | (() => HTMLElement | null) | null;
+/** A focus target: an element, a getter, `null`, or `undefined` from a policy callback. */
+type RdxFocusTarget = HTMLElement | (() => HTMLElement | null) | null | undefined;
 /** `initialFocus` policy (ADR 0017 §2) — a target, `false`, or an open-interaction callback. */
 type RdxInitialFocus = RdxFocusTarget | false | ((openInteractionType: RdxInteractionType) => RdxFocusTarget | false);
 /** `returnFocus` policy (ADR 0017 §2) — a target/boolean or a callback receiving the **close** interaction type. */
-type RdxReturnFocus = RdxFocusTarget | boolean | ((closeInteractionType: RdxInteractionType) => RdxFocusTarget | boolean);
+type RdxReturnFocus = RdxFocusTarget | boolean | ((closeInteractionType: RdxInteractionType) => RdxFocusTarget | boolean | undefined);
 /** Normalizes a DOM event into Base UI-like interaction intent for focus policy decisions. */
 declare function getInteractionTypeFromEvent(event?: Event): RdxInteractionType;
 /** Resolves an {@link RdxFocusTarget} (element | getter | null) to a concrete element. */
-declare function resolveFocusTarget(target: RdxFocusTarget): HTMLElement | null;
+declare function resolveFocusTarget(target: RdxFocusTarget): HTMLElement | null | undefined;
 /**
  * Resolves an {@link RdxInitialFocus} policy against how the popup opened.
  */
-declare function resolveInitialFocus(policy: RdxInitialFocus, openInteractionType: RdxInteractionType): HTMLElement | null | false;
+declare function resolveInitialFocus(policy: RdxInitialFocus, openInteractionType: RdxInteractionType): HTMLElement | null | false | undefined;
 /**
  * Resolves an {@link RdxReturnFocus} policy against how the popup closed. `false` = do not return focus;
  * `true` = the default (return to the previously-focused element); an element = return there.
  */
-declare function resolveReturnFocus(policy: RdxReturnFocus, closeInteractionType: RdxInteractionType): HTMLElement | boolean | null;
+declare function resolveReturnFocus(policy: RdxReturnFocus, closeInteractionType: RdxInteractionType): HTMLElement | boolean | null | undefined;
 /**
  * DI seam for a **composing primitive** (Dialog / Popover / Menu) to drive the manager's gates from its
  * own root context instead of template-bound inputs (which a primitive cannot set). Each field falls
@@ -40,9 +40,18 @@ interface RdxFloatingFocusManagerConfig {
     closeOnFocusOut?: () => boolean;
     initialFocus?: () => RdxInitialFocus;
     returnFocus?: () => RdxReturnFocus;
+    restoreFocus?: () => boolean | 'popup';
+    previousFocusableElement?: () => RdxFocusTarget;
+    nextFocusableElement?: () => RdxFocusTarget;
+    beforeContentFocusGuardRef?: () => RdxFocusGuardRef | null | undefined;
+    externalTree?: () => RdxFloatingTree | null | undefined;
+    getInsideElements?: () => Array<Element | null | undefined>;
     openInteractionType?: () => RdxInteractionType;
     closeInteractionType?: () => RdxInteractionType;
 }
+type RdxFocusGuardRef = ((element: HTMLSpanElement | null) => void) | {
+    set: (element: HTMLSpanElement | null) => void;
+};
 declare const RDX_FLOATING_FOCUS_MANAGER_CONFIG: InjectionToken<RdxFloatingFocusManagerConfig>;
 /** Provides a {@link RdxFloatingFocusManagerConfig} for an enclosing primitive's focus manager. */
 declare function provideFloatingFocusManagerConfig(factory: () => RdxFloatingFocusManagerConfig): Provider;
@@ -61,8 +70,7 @@ declare function provideFloatingFocusManagerConfig(factory: () => RdxFloatingFoc
  * - `loop` is forwarded to `RdxFocusScope`.
  * - `initialFocus` / `returnFocus` are **orchestrated** here (the §2 policy contract, incl. the
  *   interaction-type callback forms): `initialFocus` via the scope's `mountAutoFocus` hook, `returnFocus`
- *   via the scope's `returnFocus` config seam (resolved at the scope's queued post-unmount frame). The
- *   portal-focus bridge remains a later-phase dependency.
+ *   via the scope's `returnFocus` config seam (resolved at the scope's queued post-unmount frame).
  */
 declare class RdxFloatingFocusManager {
     /** Manager active-ness (ADR 0017 §2): the popup is mounted **and** not hover-opened. */
@@ -75,9 +83,25 @@ declare class RdxFloatingFocusManager {
      */
     readonly inert: _angular_core.InputSignalWithTransform<boolean | undefined, BooleanInput>;
     /** Where focus goes when the popup opens (ADR 0017 §2). */
-    readonly initialFocus: _angular_core.InputSignal<RdxInitialFocus | undefined>;
+    readonly initialFocus: _angular_core.InputSignal<RdxInitialFocus>;
     /** Where focus returns when the popup closes (ADR 0017 §2). */
-    readonly returnFocus: _angular_core.InputSignal<RdxReturnFocus | undefined>;
+    readonly returnFocus: _angular_core.InputSignal<RdxReturnFocus>;
+    /**
+     * Restores focus inside the floating tree when the currently focused inside element is removed and
+     * the browser drops focus onto `<body>` (Base UI `restoreFocus`). `true` restores to the last
+     * available tabbable candidate, `'popup'` restores to the popup container.
+     */
+    readonly restoreFocus: _angular_core.InputSignal<boolean | "popup" | undefined>;
+    /** Overrides where backward tabbing out of a non-modal portaled popup lands. */
+    readonly previousFocusableElement: _angular_core.InputSignal<RdxFocusTarget>;
+    /** Overrides where forward tabbing out of a non-modal portaled popup lands. */
+    readonly nextFocusableElement: _angular_core.InputSignal<RdxFocusTarget>;
+    /** Optional callback/signal that receives the leading content focus guard. */
+    readonly beforeContentFocusGuardRef: _angular_core.InputSignal<RdxFocusGuardRef | null | undefined>;
+    /** Explicit floating tree for detached sibling composition (Base UI `externalTree`). */
+    readonly externalTree: _angular_core.InputSignal<RdxFloatingTree | null | undefined>;
+    /** Additional elements treated as inside the floating subtree (Base UI `getInsideElements`). */
+    readonly getInsideElements: _angular_core.InputSignal<(() => Array<Element | null | undefined>) | undefined>;
     /**
      * Whether a **non-modal** popup closes when focus leaves to an unrelated node (Base UI
      * `closeOnFocusOut`, default `true`; Dialog sets it to `!disablePointerDismissal`). Modal popups
@@ -98,7 +122,13 @@ declare class RdxFloatingFocusManager {
     readonly effectiveInert: _angular_core.Signal<boolean>;
     readonly effectiveCloseOnFocusOut: _angular_core.Signal<boolean>;
     readonly effectiveInitialFocus: _angular_core.Signal<false | HTMLElement | ((openInteractionType: RdxInteractionType) => RdxFocusTarget | false) | null>;
-    readonly effectiveReturnFocus: _angular_core.Signal<boolean | HTMLElement | ((closeInteractionType: RdxInteractionType) => RdxFocusTarget | boolean)>;
+    readonly effectiveReturnFocus: _angular_core.Signal<boolean | HTMLElement | ((closeInteractionType: RdxInteractionType) => RdxFocusTarget | boolean | undefined)>;
+    readonly effectiveRestoreFocus: _angular_core.Signal<boolean | "popup">;
+    readonly effectivePreviousFocusableElement: _angular_core.Signal<RdxFocusTarget>;
+    readonly effectiveNextFocusableElement: _angular_core.Signal<RdxFocusTarget>;
+    readonly effectiveBeforeContentFocusGuardRef: _angular_core.Signal<RdxFocusGuardRef | null | undefined>;
+    readonly effectiveExternalTree: _angular_core.Signal<RdxFloatingTree | null>;
+    readonly insideElements: _angular_core.Signal<Element[]>;
     readonly effectiveOpenInteractionType: _angular_core.Signal<RdxInteractionType>;
     readonly effectiveCloseInteractionType: _angular_core.Signal<RdxInteractionType>;
     /** The effective trap state the composed `RdxFocusScope` reads via its config token. */
@@ -155,6 +185,17 @@ declare class RdxFloatingFocusManager {
      * `FloatingFocusManager` `!modal` branch (`movedToUnrelatedNode`).
      */
     private wireCloseOnFocusOut;
+    /**
+     * Restore focus when an inside focused element disappears and the document focus falls back to
+     * `<body>`. This mirrors the practical Base UI `restoreFocus` path used by Select while keeping the
+     * broader portal-guard navigation separate.
+     */
+    private wireRestoreFocus;
+    /**
+     * Portal focus bridge (Base UI inside guards): when focus reaches the hidden guards around portaled
+     * content, redirect it either back inside the popup or to the configured neighboring tabbable node.
+     */
+    private wirePortalFocusBridge;
     /**
      * The marker keep-set is intentionally narrow: the popup/focus host only. Own sibling roots such as a
      * user backdrop are DOM-footprint bookkeeping, not marker keep-set members.
@@ -164,12 +205,68 @@ declare class RdxFloatingFocusManager {
     /** Whether `relatedTarget` is inside the popup, its trigger(s), or an ancestor / descendant popup. */
     private isRelatedTargetInside;
     private contextContains;
+    private currentFloatingNode;
+    private getTabbableContent;
+    private portalFocusContainer;
+    private defaultPreviousFocusable;
+    private defaultNextFocusable;
+    private setBeforeContentFocusGuardRef;
+    private isFromOutsideFocusGuard;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxFloatingFocusManager, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxFloatingFocusManager, "[rdxFloatingFocusManager]", ["rdxFloatingFocusManager"], { "enabled": { "alias": "enabled"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "inert": { "alias": "inert"; "required": false; "isSignal": true; }; "initialFocus": { "alias": "initialFocus"; "required": false; "isSignal": true; }; "returnFocus": { "alias": "returnFocus"; "required": false; "isSignal": true; }; "closeOnFocusOut": { "alias": "closeOnFocusOut"; "required": false; "isSignal": true; }; }, { "focusOut": "focusOut"; }, never, never, true, [{ directive: typeof i1.RdxFocusScope; inputs: { "loop": "loop"; }; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxFloatingFocusManager, "[rdxFloatingFocusManager]", ["rdxFloatingFocusManager"], { "enabled": { "alias": "enabled"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "inert": { "alias": "inert"; "required": false; "isSignal": true; }; "initialFocus": { "alias": "initialFocus"; "required": false; "isSignal": true; }; "returnFocus": { "alias": "returnFocus"; "required": false; "isSignal": true; }; "restoreFocus": { "alias": "restoreFocus"; "required": false; "isSignal": true; }; "previousFocusableElement": { "alias": "previousFocusableElement"; "required": false; "isSignal": true; }; "nextFocusableElement": { "alias": "nextFocusableElement"; "required": false; "isSignal": true; }; "beforeContentFocusGuardRef": { "alias": "beforeContentFocusGuardRef"; "required": false; "isSignal": true; }; "externalTree": { "alias": "externalTree"; "required": false; "isSignal": true; }; "getInsideElements": { "alias": "getInsideElements"; "required": false; "isSignal": true; }; "closeOnFocusOut": { "alias": "closeOnFocusOut"; "required": false; "isSignal": true; }; }, { "focusOut": "focusOut"; }, never, never, true, [{ directive: typeof i1.RdxFocusScope; inputs: { "loop": "loop"; }; outputs: {}; }]>;
 }
 
 /** The neutral "outside the active floating layer" marker (Base UI `data-base-ui-inert`). */
 declare const RDX_FLOATING_MARKER = "data-rdx-floating-inert";
 
-export { RDX_FLOATING_FOCUS_MANAGER_CONFIG, RDX_FLOATING_MARKER, RdxFloatingFocusManager, getInteractionTypeFromEvent, provideFloatingFocusManagerConfig, resolveFocusTarget, resolveInitialFocus, resolveReturnFocus };
-export type { RdxFloatingFocusManagerConfig, RdxFocusTarget, RdxInitialFocus, RdxInteractionType, RdxReturnFocus };
+interface RdxTriggerInteractionOptions {
+    trigger: () => HTMLElement;
+    open: () => boolean;
+    activeTrigger?: () => HTMLElement | null | undefined;
+    disabled?: () => boolean;
+    contentId?: () => string | null | undefined;
+}
+interface RdxTriggerInteraction {
+    readonly lastPointerType: Signal<string>;
+    readonly isActive: Signal<boolean>;
+    readonly isInactive: Signal<boolean>;
+    readonly dataState: Signal<'open' | 'closed'>;
+    readonly dataPopupOpen: Signal<'' | undefined>;
+    readonly ariaControls: Signal<string | undefined>;
+    readonly ariaExpanded: Signal<boolean>;
+    readonly disabled: Signal<boolean>;
+    recordPointerDown: (event: PointerEvent) => void;
+    clickInteractionType: (event: MouseEvent) => RdxInteractionType;
+}
+interface RdxTriggerFocusGuardOptions {
+    trigger: () => HTMLElement;
+    close: (event: FocusEvent) => void;
+    beforeContentFocusGuard?: () => HTMLElement | null | undefined;
+    contentId?: () => string | null | undefined;
+    enabled?: () => boolean;
+    popupElement?: () => HTMLElement | null | undefined;
+}
+interface RdxTriggerFocusGuardAnchorOptions {
+    trigger: () => HTMLElement;
+    contentId: () => string | null | undefined;
+    enabled?: () => boolean;
+}
+/**
+ * Shared trigger state for floating primitives. It intentionally stays small: each primitive still owns
+ * its open/close business rules, while this layer normalizes active-trigger state and the open method
+ * signal that must be captured before the popup/focus manager mounts.
+ */
+declare function createRdxTriggerInteraction(options: RdxTriggerInteractionOptions): RdxTriggerInteraction;
+/**
+ * Adds Base UI's trigger-side focus guards for portaled content. The content guards remain owned by
+ * `RdxFloatingFocusManager`; these guards bridge tab order from the trigger into the portal and close the
+ * popup when focus leaves past either trigger-side boundary.
+ */
+declare function useTriggerFocusGuards(options: RdxTriggerFocusGuardOptions): void;
+/**
+ * Backwards-compatible aria-owns-only bridge for modal popups that do not need trigger-side tab guards.
+ */
+declare function useTriggerFocusGuardAnchor(options: RdxTriggerFocusGuardAnchorOptions): void;
+
+export { RDX_FLOATING_FOCUS_MANAGER_CONFIG, RDX_FLOATING_MARKER, RdxFloatingFocusManager, createRdxTriggerInteraction, getInteractionTypeFromEvent, provideFloatingFocusManagerConfig, resolveFocusTarget, resolveInitialFocus, resolveReturnFocus, useTriggerFocusGuardAnchor, useTriggerFocusGuards };
+export type { RdxFloatingFocusManagerConfig, RdxFocusGuardRef, RdxFocusTarget, RdxInitialFocus, RdxInteractionType, RdxReturnFocus, RdxTriggerFocusGuardAnchorOptions, RdxTriggerFocusGuardOptions, RdxTriggerInteraction, RdxTriggerInteractionOptions };

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

@@ -2,11 +2,12 @@ import * as _angular_core from '@angular/core';
 import { Signal, WritableSignal } from '@angular/core';
 import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
 import { RdxFloatingRootContext, BooleanInput, Direction, RdxCancelableChangeEventDetails, NumberInput } from '@radix-ng/primitives/core';
-import * as i3 from '@radix-ng/primitives/floating-focus-manager';
+import * as _radix_ng_primitives_floating_focus_manager from '@radix-ng/primitives/floating-focus-manager';
 import { RdxInteractionType } from '@radix-ng/primitives/floating-focus-manager';
 import * as i1 from '@radix-ng/primitives/popper';
 import { RdxPopperContentWrapper } from '@radix-ng/primitives/popper';
 import * as _radix_ng_primitives_menu from '@radix-ng/primitives/menu';
+import * as i2 from '@radix-ng/primitives/composite';
 import * as i1$1 from '@radix-ng/primitives/portal';
 import { RdxOutsidePressDomEvent } from '@radix-ng/primitives/dismissable-layer';
 
@@ -71,6 +72,7 @@ interface RdxMenuRootContext {
     trigger: Signal<HTMLElement | undefined>;
     /** The popup element, once mounted. Used by submenu safe-polygon geometry. */
     popupElement: Signal<HTMLElement | undefined>;
+    beforeContentFocusGuard: Signal<HTMLElement | null>;
     transitionStatus: Signal<RdxMenuTransitionStatus>;
     close: (reason?: RdxMenuOpenChangeReason, event?: Event) => void;
     /** Close this menu and every ancestor — used by item selection (the whole menu dismisses). */
@@ -81,6 +83,7 @@ interface RdxMenuRootContext {
     showWithoutAutoFocus: (reason?: RdxMenuOpenChangeReason, event?: Event) => void;
     registerTrigger: (el: HTMLElement) => () => void;
     registerPopup: (el: HTMLElement) => () => void;
+    setBeforeContentFocusGuard: (element: HTMLElement | null) => void;
     registerTransitionElement: (element: HTMLElement) => () => void;
     registerPopupArrowNavigationHandler: (handler: (offset: 1 | -1) => boolean) => () => void;
     registerTriggerInteractionHandler: (handler: RdxMenuTriggerInteractionHandler) => () => void;
@@ -174,6 +177,7 @@ declare class RdxMenuRoot {
     readonly onOpenChangeComplete: _angular_core.OutputEmitterRef<boolean>;
     readonly trigger: _angular_core.WritableSignal<HTMLElement | undefined>;
     readonly popupElement: _angular_core.WritableSignal<HTMLElement | undefined>;
+    readonly beforeContentFocusGuard: _angular_core.WritableSignal<HTMLElement | null>;
     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>;
@@ -214,6 +218,7 @@ declare class RdxMenuRoot {
     closeEntireMenu(reason?: RdxMenuOpenChangeReason, event?: Event): void;
     registerTrigger(el: HTMLElement): () => void;
     registerPopup(el: HTMLElement): () => void;
+    setBeforeContentFocusGuard(element: HTMLElement | null): void;
     registerTransitionElement(element: HTMLElement): () => void;
     registerPopupArrowNavigationHandler(handler: (offset: 1 | -1) => boolean): () => void;
     handlePopupArrowNavigation(offset: 1 | -1): boolean;
@@ -222,6 +227,7 @@ declare class RdxMenuRoot {
     markAsSubmenu(): void;
     closeParent(): void;
     private createOpenChangeEvent;
+    private focusOpenPopup;
     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; }; "dirInput": { "alias": "dir"; "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: {}; }]>;
 }
@@ -253,8 +259,10 @@ declare class RdxMenuTrigger {
     readonly closeDelay: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
     protected readonly nativeButtonState: _angular_core.Signal<boolean>;
     protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly triggerInteraction: _radix_ng_primitives_floating_focus_manager.RdxTriggerInteraction;
     constructor();
     protected handleMouseDown(event: MouseEvent): void;
+    protected handlePointerDown(event: PointerEvent): void;
     protected handleClick(event: MouseEvent): void;
     protected handleArrowDown(event: Event): void;
     protected handleArrowUp(event: Event): void;
@@ -274,7 +282,7 @@ declare class RdxMenuTrigger {
     private clearMouseUpGuard;
     private restoreKeyboardPopupFocus;
     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: {}; }]>;
+    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: {}; }, { directive: typeof i2.RdxCompositeItem; inputs: {}; outputs: {}; }]>;
 }
 
 /**
@@ -384,7 +392,7 @@ declare class RdxMenuPopup {
     private readonly elementRef;
     private search;
     private searchTimer;
-    protected readonly align: _angular_core.Signal<"end" | "start" | "center" | undefined>;
+    protected readonly align: _angular_core.Signal<"center" | "end" | "start" | undefined>;
     protected readonly side: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
     /**
      * Event handler called when the escape key is pressed. Can be prevented.
@@ -416,7 +424,7 @@ declare class RdxMenuPopup {
     private scheduleSubmenuKeyboardFocus;
     private applySubmenuKeyboardFocus;
     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 _radix_ng_primitives_core.RdxFloatingNodeRegistration; inputs: {}; outputs: {}; }, { directive: typeof i3.RdxFloatingFocusManager; inputs: {}; outputs: {}; }]>;
+    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 _radix_ng_primitives_core.RdxFloatingNodeRegistration; inputs: {}; outputs: {}; }, { directive: typeof _radix_ng_primitives_floating_focus_manager.RdxFloatingFocusManager; inputs: {}; outputs: {}; }]>;
 }
 
 /**
@@ -470,7 +478,7 @@ 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 align: _angular_core.Signal<"center" | "end" | "start" | 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: {}; }]>;

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

@@ -2,6 +2,7 @@ import * as _angular_core from '@angular/core';
 import { Signal } from '@angular/core';
 import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
 import { BooleanInput } from '@radix-ng/primitives/core';
+import * as i1 from '@radix-ng/primitives/composite';
 
 type RdxMenubarOrientation = 'horizontal' | 'vertical';
 interface RdxMenubarContext {
@@ -22,9 +23,12 @@ declare const provideRdxMenubarContext: (useFactory: () => RdxMenubarContext) =>
  * Coordinates open/close state across multiple menus and provides arrow-key navigation.
  */
 declare class RdxMenubarRoot {
+    private readonly elementRef;
+    private readonly compositeRoot;
     private readonly menuRoots;
     private readonly ids;
     private items;
+    private readonly itemsVersion;
     /** Whether every menubar trigger is disabled. */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /** Whether arrow-key navigation wraps at the first/last trigger. */
@@ -46,15 +50,16 @@ declare class RdxMenubarRoot {
     private handleTriggerArrow;
     private handleTriggerBoundary;
     focusAdjacent(currentId: string, offset: 1 | -1, openOnMove: boolean): void;
-    protected handleArrowLeft(event: Event): void;
-    protected handleArrowRight(event: Event): void;
-    private handleOpenMenuNavigation;
     private focusItem;
-    private updateTriggerTabStops;
+    protected handleFocusIn(event: FocusEvent): void;
+    private highlightItem;
     private enabledItems;
     private hasOpenMenu;
+    private sortItems;
+    private markItemsChanged;
+    private syncDisabledIndices;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenubarRoot, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenubarRoot, "[rdxMenubarRoot]", ["rdxMenubarRoot"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loopFocus": { "alias": "loopFocus"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, {}, ["menuRoots"], never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenubarRoot, "[rdxMenubarRoot]", ["rdxMenubarRoot"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loopFocus": { "alias": "loopFocus"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, {}, ["menuRoots"], never, true, [{ directive: typeof i1.RdxCompositeRoot; inputs: {}; outputs: {}; }]>;
 }
 
 declare class RdxMenubarModule {

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

@@ -2,17 +2,17 @@ import * as _angular_core from '@angular/core';
 import { TemplateRef, Signal } from '@angular/core';
 import * as i1 from '@radix-ng/primitives/portal';
 import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
-import { RdxCancelableChangeEventDetails, RdxTransitionStatus, RdxFloatingRootContext, BooleanInput, NumberInput } from '@radix-ng/primitives/core';
+import { RdxCancelableChangeEventDetails, RdxTransitionStatus, RdxFloatingRootContext, NumberInput } from '@radix-ng/primitives/core';
 import * as i1$1 from '@radix-ng/primitives/popper';
 import { RdxPopperContentWrapper } from '@radix-ng/primitives/popper';
 import * as _radix_ng_primitives_navigation_menu from '@radix-ng/primitives/navigation-menu';
-import * as i1$2 from '@radix-ng/primitives/roving-focus';
+import * as i1$2 from '@radix-ng/primitives/composite';
 import { RdxOutsidePressDomEvent } from '@radix-ng/primitives/dismissable-layer';
 
 /**
  * Structural directive that teleports the navigation menu popup into a container (default
  * `document.body`) while the menu is open, and keeps it mounted until any CSS exit `@keyframes`
- * finishes.
+ * finishes. Set `[keepMounted]="true"` to keep the portal mounted while closed.
  *
  * Apply it with the `*` microsyntax on the positioner —
  * `<div *rdxNavigationMenuPortal rdxNavigationMenuPositioner>` — or as an explicit
@@ -20,8 +20,14 @@ import { RdxOutsidePressDomEvent } from '@radix-ng/primitives/dismissable-layer'
  * `[container]`.
  */
 declare class RdxNavigationMenuPortal {
+    private readonly rootContext;
+    /**
+     * Keep the portal mounted while the menu is closed.
+     */
+    readonly keepMounted: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly present: _angular_core.Signal<boolean>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNavigationMenuPortal, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNavigationMenuPortal, "ng-template[rdxNavigationMenuPortal]", ["rdxNavigationMenuPortal"], {}, {}, never, never, true, [{ directive: typeof i1.RdxPortalPresence; inputs: { "container": "container"; }; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNavigationMenuPortal, "ng-template[rdxNavigationMenuPortal]", ["rdxNavigationMenuPortal"], { "keepMounted": { "alias": "keepMounted"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.RdxPortalPresence; inputs: { "container": "container"; }; outputs: {}; }]>;
 }
 /**
  * Dev-mode guard: `rdxNavigationMenuPortal` used to be an attribute directive on a `<div>`. It is now
@@ -36,7 +42,7 @@ declare class RdxNavigationMenuPortalMisuseGuard {
 
 type NavigationMenuOrientation = 'horizontal' | 'vertical';
 type NavigationMenuDirection = 'ltr' | 'rtl';
-type RdxNavigationMenuOpenChangeReason = 'trigger-hover' | 'trigger-focus' | 'trigger-press' | 'list-navigation' | 'outside-press' | 'focus-out' | 'escape-key' | 'link-select' | 'list-leave' | 'none';
+type RdxNavigationMenuOpenChangeReason = 'trigger-hover' | 'trigger-press' | 'list-navigation' | 'outside-press' | 'focus-out' | 'escape-key' | 'link-select' | 'list-leave' | 'none';
 type RdxNavigationMenuOpenChangeEventDetails = RdxCancelableChangeEventDetails<RdxNavigationMenuOpenChangeReason>;
 interface RdxNavigationMenuOpenChange {
     value: string | null;
@@ -62,7 +68,6 @@ interface RdxNavigationMenuRootContext {
     readonly baseId: string;
     readonly orientation: Signal<NavigationMenuOrientation>;
     readonly dir: Signal<NavigationMenuDirection>;
-    readonly loop: Signal<boolean>;
     /** Value of the currently open item, or `null` when closed. */
     readonly value: Signal<string | null>;
     /** Value of the previously open item (used for slide-direction morphing). */
@@ -74,7 +79,14 @@ interface RdxNavigationMenuRootContext {
     /** The active trigger element the popup is anchored to. */
     readonly trigger: Signal<HTMLElement | undefined>;
     readonly triggers: Signal<HTMLElement[]>;
+    readonly list: Signal<HTMLElement | undefined>;
+    readonly contents: Signal<Map<string, RdxNavigationMenuContentEntry>>;
     readonly activeContent: Signal<RdxNavigationMenuContentEntry | undefined>;
+    readonly popup: Signal<HTMLElement | undefined>;
+    readonly size: Signal<{
+        width: number;
+        height: number;
+    } | null>;
     contentId(value: string): string;
     triggerId(value: string): string;
     setValue(value: string | null, reason?: RdxNavigationMenuOpenChangeReason, event?: Event): void;
@@ -85,8 +97,14 @@ interface RdxNavigationMenuRootContext {
     closeOnHover(event?: PointerEvent): void;
     cancelHoverOpen(): void;
     cancelHoverClose(): void;
+    setSize(size: {
+        width: number;
+        height: number;
+    } | null): void;
     registerTrigger(value: string, trigger: HTMLElement): () => void;
+    registerList(list: HTMLElement): () => void;
     registerContent(entry: RdxNavigationMenuContentEntry): () => void;
+    registerPopup(element: HTMLElement): () => void;
     registerTransitionElement(element: HTMLElement): () => void;
     registerViewport(onTriggerChange: (previous: HTMLElement, next: HTMLElement) => void): () => void;
 }
@@ -127,10 +145,6 @@ declare class RdxNavigationMenuRoot {
      */
     readonly dirInput: _angular_core.InputSignal<NavigationMenuDirection | undefined>;
     readonly dir: _angular_core.Signal<_radix_ng_primitives_core.Direction>;
-    /**
-     * Whether keyboard navigation loops from the last item back to the first and vice versa.
-     */
-    readonly loop: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /**
      * How long to wait before opening the menu on hover, in milliseconds.
      */
@@ -164,7 +178,13 @@ declare class RdxNavigationMenuRoot {
     readonly present: _angular_core.Signal<boolean>;
     readonly trigger: _angular_core.WritableSignal<HTMLElement | undefined>;
     readonly triggers: _angular_core.WritableSignal<HTMLElement[]>;
+    readonly list: _angular_core.WritableSignal<HTMLElement | undefined>;
     readonly contents: _angular_core.WritableSignal<Map<string, RdxNavigationMenuContentEntry>>;
+    readonly popup: _angular_core.WritableSignal<HTMLElement | undefined>;
+    readonly size: _angular_core.WritableSignal<{
+        width: number;
+        height: number;
+    } | null>;
     readonly activeContent: _angular_core.Signal<RdxNavigationMenuContentEntry | undefined>;
     private readonly registeredTriggers;
     private readonly viewportTriggerChange;
@@ -180,7 +200,13 @@ declare class RdxNavigationMenuRoot {
     cancelHoverOpen(): void;
     cancelHoverClose(): void;
     registerTrigger(value: string, trigger: HTMLElement): () => void;
+    registerList(list: HTMLElement): () => void;
     registerContent(entry: RdxNavigationMenuContentEntry): () => void;
+    registerPopup(element: HTMLElement): () => void;
+    setSize(size: {
+        width: number;
+        height: number;
+    } | null): void;
     registerTransitionElement(element: HTMLElement): () => void;
     registerViewport(onTriggerChange: (previous: HTMLElement, next: HTMLElement) => void): () => boolean;
     private createOpenChangeEvent;
@@ -190,19 +216,20 @@ declare class RdxNavigationMenuRoot {
     private clearCloseTimer;
     private isInsideOpenChild;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNavigationMenuRoot, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNavigationMenuRoot, "[rdxNavigationMenuRoot]", ["rdxNavigationMenuRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "dirInput": { "alias": "dir"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onValueChange": "onValueChange"; "onOpenChange": "onOpenChange"; "onOpenChangeComplete": "onOpenChangeComplete"; }, never, never, true, [{ directive: typeof i1$1.RdxPopper; inputs: {}; outputs: {}; }, { directive: typeof _radix_ng_primitives_core.RdxFloatingNodeRegistration; inputs: {}; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNavigationMenuRoot, "[rdxNavigationMenuRoot]", ["rdxNavigationMenuRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "dirInput": { "alias": "dir"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onValueChange": "onValueChange"; "onOpenChange": "onOpenChange"; "onOpenChangeComplete": "onOpenChangeComplete"; }, never, never, true, [{ directive: typeof i1$1.RdxPopper; inputs: {}; outputs: {}; }, { directive: typeof _radix_ng_primitives_core.RdxFloatingNodeRegistration; inputs: {}; outputs: {}; }]>;
 }
 
 /**
- * Contains the navigation menu items. Renders as a menubar with roving keyboard focus.
+ * Contains the navigation menu items and coordinates composite keyboard focus between triggers.
  */
 declare class RdxNavigationMenuList {
     protected readonly rootContext: _radix_ng_primitives_navigation_menu.RdxNavigationMenuRootContext;
-    private readonly rovingFocusGroup;
+    private readonly compositeRoot;
     constructor();
+    protected onKeydown(event: KeyboardEvent): void;
     protected onPointerLeave(event: PointerEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNavigationMenuList, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNavigationMenuList, "[rdxNavigationMenuList]", never, {}, {}, never, never, true, [{ directive: typeof i1$2.RdxRovingFocusGroupDirective; inputs: {}; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNavigationMenuList, "[rdxNavigationMenuList]", never, {}, {}, never, never, true, [{ directive: typeof i1$2.RdxCompositeRoot; inputs: {}; outputs: {}; }]>;
 }
 
 /**
@@ -229,8 +256,7 @@ declare class RdxNavigationMenuItem {
  */
 declare class RdxNavigationMenuTrigger {
     protected readonly item: RdxNavigationMenuItem;
-    private readonly rootContext;
-    private readonly rovingFocusItem;
+    protected readonly rootContext: _radix_ng_primitives_navigation_menu.RdxNavigationMenuRootContext;
     private readonly elementRef;
     private readonly document;
     /**
@@ -246,18 +272,12 @@ declare class RdxNavigationMenuTrigger {
     protected onClick(event: MouseEvent): void;
     protected onPointerEnter(event: PointerEvent): void;
     protected onPointerLeave(event: PointerEvent): void;
-    /**
-     * Open-follows-focus: while the menu is already open, moving keyboard focus (arrow keys via
-     * roving) to another trigger switches the shared popup to that item — matching Base UI, so the
-     * open menu visibly responds to arrow-key navigation. Focus never *opens* a closed menu.
-     */
-    protected onFocus(): void;
     protected onKeydown(event: KeyboardEvent): void;
     /** The key that moves focus from the trigger into the open content, based on orientation/dir. */
     private entryKey;
     private focusContent;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNavigationMenuTrigger, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNavigationMenuTrigger, "button[rdxNavigationMenuTrigger]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "openOnHover": { "alias": "openOnHover"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$2.RdxRovingFocusItemDirective; inputs: {}; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNavigationMenuTrigger, "button[rdxNavigationMenuTrigger]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "openOnHover": { "alias": "openOnHover"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$2.RdxCompositeItem; inputs: {}; outputs: {}; }]>;
 }
 
 /**
@@ -297,10 +317,10 @@ declare class RdxNavigationMenuContent {
 }
 
 /**
- * A navigation link. Closes the menu on selection unless prevented.
+ * A navigation link. Can close the menu on selection when `closeOnClick` is enabled.
  *
- * Used both as a top-level menubar item and inside content. It is a plain tabbable anchor (not part
- * of the menubar's arrow-key roving), matching Base UI.
+ * Used both as a top-level navigation item and inside content. Top-level links join the list's
+ * composite collection, matching Base UI's CompositeItem-backed NavigationMenu.Link.
  */
 declare class RdxNavigationMenuLink {
     private readonly rootContext;
@@ -320,7 +340,7 @@ declare class RdxNavigationMenuLink {
     protected onClick(event: Event): void;
     protected onKeydown(event: KeyboardEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNavigationMenuLink, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNavigationMenuLink, "[rdxNavigationMenuLink]", never, { "active": { "alias": "active"; "required": false; "isSignal": true; }; "closeOnClick": { "alias": "closeOnClick"; "required": false; "isSignal": true; }; }, { "onSelect": "onSelect"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNavigationMenuLink, "[rdxNavigationMenuLink]", never, { "active": { "alias": "active"; "required": false; "isSignal": true; }; "closeOnClick": { "alias": "closeOnClick"; "required": false; "isSignal": true; }; }, { "onSelect": "onSelect"; }, never, never, true, [{ directive: typeof i1$2.RdxCompositeItem; inputs: {}; outputs: {}; }]>;
 }
 
 /**
@@ -328,6 +348,7 @@ declare class RdxNavigationMenuLink {
  */
 declare class RdxNavigationMenuBackdrop {
     protected readonly rootContext: _radix_ng_primitives_navigation_menu.RdxNavigationMenuRootContext;
+    constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNavigationMenuBackdrop, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNavigationMenuBackdrop, "[rdxNavigationMenuBackdrop]", never, {}, {}, never, never, true, never>;
 }
@@ -362,8 +383,7 @@ declare class RdxNavigationMenuPopup {
     private readonly elementRef;
     protected readonly side: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
     protected readonly align: _angular_core.Signal<"start" | "center" | "end" | undefined>;
-    /** Names the menu after the active trigger so the `role="menu"` element has an accessible name. */
-    protected readonly labelledBy: _angular_core.Signal<string | undefined>;
+    protected readonly id: _angular_core.Signal<string>;
     /**
      * Event handler called when the escape key is down. Can be prevented.
      */
@@ -379,11 +399,15 @@ declare class RdxNavigationMenuPopup {
     constructor();
     protected onPointerLeave(event: PointerEvent): void;
     /**
-     * Keyboard navigation inside the open panel: Down/Up move between the panel's focusable items in
-     * DOM order, Home/End jump to the first/last, and Up from the first item returns focus to the
-     * trigger. (Tab keeps working natively; Escape is handled by the dismissal capability.)
+     * Keyboard navigation inside the open panel mirrors Base UI's CompositeRoot-backed content:
+     * arrow keys move between panel focusables in DOM order, Home/End jump to the first/last, Up from
+     * the first item returns focus to the trigger, and Tab exits the portalled panel through the
+     * logical top-level navigation order. Escape is handled by the dismissal capability.
      */
     protected onKeydown(event: KeyboardEvent): void;
+    private handleTabKey;
+    private getNextTopLevelItem;
+    private getTopLevelItems;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNavigationMenuPopup, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNavigationMenuPopup, "[rdxNavigationMenuPopup]", never, {}, { "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; "focusOutside": "focusOutside"; }, never, never, true, [{ directive: typeof i1$1.RdxPopperContent; inputs: {}; outputs: {}; }]>;
 }
@@ -422,13 +446,21 @@ declare class RdxNavigationMenuViewport {
         height: number;
     } | null>;
     private current;
+    private readonly rendered;
     private previousElement;
     private pendingDirection;
     private cleanupTimer;
     private readonly resizeObserver;
     private readonly activeContent;
+    private readonly contents;
     constructor();
+    private sync;
     private render;
+    private createRendered;
+    private deactivateCurrent;
+    private markCurrent;
+    private markInactive;
+    private destroyRendered;
     private startLeave;
     private removePrevious;
     private clearCleanupTimer;
@@ -437,7 +469,7 @@ declare class RdxNavigationMenuViewport {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNavigationMenuViewport, "[rdxNavigationMenuViewport]", never, { "forceMount": { "alias": "forceMount"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare const navigationMenuImports: (typeof RdxNavigationMenuPortal)[];
+declare const navigationMenuImports: (typeof RdxNavigationMenuPortalMisuseGuard)[];
 declare class RdxNavigationMenuModule {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNavigationMenuModule, never>;
     static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxNavigationMenuModule, never, [typeof RdxNavigationMenuRoot, typeof RdxNavigationMenuList, typeof RdxNavigationMenuItem, typeof RdxNavigationMenuTrigger, typeof RdxNavigationMenuIcon, typeof RdxNavigationMenuContent, typeof RdxNavigationMenuLink, typeof RdxNavigationMenuPortal, typeof RdxNavigationMenuPortalMisuseGuard, typeof RdxNavigationMenuBackdrop, typeof RdxNavigationMenuPositioner, typeof RdxNavigationMenuPopup, typeof RdxNavigationMenuArrow, typeof RdxNavigationMenuViewport], [typeof RdxNavigationMenuRoot, typeof RdxNavigationMenuList, typeof RdxNavigationMenuItem, typeof RdxNavigationMenuTrigger, typeof RdxNavigationMenuIcon, typeof RdxNavigationMenuContent, typeof RdxNavigationMenuLink, typeof RdxNavigationMenuPortal, typeof RdxNavigationMenuPortalMisuseGuard, typeof RdxNavigationMenuBackdrop, typeof RdxNavigationMenuPositioner, typeof RdxNavigationMenuPopup, typeof RdxNavigationMenuArrow, typeof RdxNavigationMenuViewport]>;