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

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

@@ -1,406 +1,488 @@
-import * as i0 from '@angular/core';
-import { OnDestroy, WritableSignal, ElementRef, Signal, AfterContentInit, AfterViewInit, OnInit, EventEmitter, InjectionToken, Type, Provider } from '@angular/core';
-import { Subject } from 'rxjs';
-import { FocusableOption, FocusKeyManager } from '@angular/cdk/a11y';
-import * as i1 from '@radix-ng/primitives/roving-focus';
+import * as _angular_core from '@angular/core';
+import { TemplateRef, Signal, ElementRef } from '@angular/core';
+import * as i1 from '@radix-ng/primitives/presence';
+import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
+import { RdxTransitionStatus, BooleanInput, NumberInput } from '@radix-ng/primitives/core';
+import * as i1$1 from '@radix-ng/primitives/popper';
+import { RdxPopperContentWrapper, RdxPopperAnchorElement } 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$3 from '@radix-ng/primitives/portal';
+import { RdxPortalContainer } from '@radix-ng/primitives/portal';
+import * as i2 from '@radix-ng/primitives/dismissable-layer';
 
-declare enum RdxNavigationMenuAnimationStatus {
-    OPEN_STARTED = "open_started",
-    OPEN_ENDED = "open_ended",
-    CLOSED_STARTED = "closed_started",
-    CLOSED_ENDED = "closed_ended"
-}
 /**
- * A stub class solely used to query a single type of focusable element in the navigation menu.
+ * Mounts the popup while the menu is open and waits for CSS exit keyframes before unmounting.
+ *
+ * ```html
+ * <ng-template rdxNavigationMenuPortalPresence>…</ng-template>
+ * ```
  */
-declare abstract class RdxNavigationMenuFocusableOption implements FocusableOption {
-    focus(): void;
+declare class RdxNavigationMenuPortalPresence {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNavigationMenuPortalPresence, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNavigationMenuPortalPresence, "ng-template[rdxNavigationMenuPortalPresence]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxPresenceDirective; inputs: {}; outputs: {}; }]>;
 }
 
-declare enum RdxNavigationMenuAction {
-    OPEN = "open",
-    CLOSE = "close"
+type NavigationMenuOrientation = 'horizontal' | 'vertical';
+type NavigationMenuDirection = 'ltr' | 'rtl';
+type RdxNavigationMenuOpenChangeReason = 'trigger-hover' | 'trigger-focus' | 'trigger-press' | 'outside-press' | 'focus-out' | 'escape-key' | 'link-select' | 'list-leave' | 'none';
+interface RdxNavigationMenuOpenChange {
+    value: string | null;
+    open: boolean;
+    reason: RdxNavigationMenuOpenChangeReason;
+    event: Event;
 }
-declare class RdxNavigationMenuDirective implements OnDestroy {
-    #private;
-    private readonly elementRef;
-    private readonly document;
-    private readonly window;
-    readonly baseId: string;
-    userDismissedByClick: () => boolean;
-    resetUserDismissed: () => void;
-    private openTimerRef;
-    private closeTimerRef;
-    private skipDelayTimerRef;
-    private recentlyActivatedTimerRef;
-    private readonly recentlyActivatedItem;
-    private documentMouseLeaveHandler;
-    readonly actionSubject$: Subject<{
-        action: RdxNavigationMenuAction;
-        itemValue?: string;
-    }>;
-    orientation: 'horizontal' | 'vertical';
-    dir: 'ltr' | 'rtl';
-    clickIgnoreDuration: number;
-    delayDuration: number;
-    skipDelayDuration: number;
-    loop: boolean;
-    cssAnimation: boolean;
-    cssOpeningAnimation: boolean;
-    cssClosingAnimation: boolean;
-    readonly isRootMenu = true;
-    readonly cssAnimationStatus: WritableSignal<RdxNavigationMenuAnimationStatus | null>;
-    value: () => string;
-    previousValue: () => string;
-    rootNavigationMenu: () => HTMLElement | null;
-    indicatorTrack: () => HTMLElement | null;
-    viewport: () => HTMLElement | null;
-    viewportContent: () => Map<string, any>;
-    setTriggerPointerState: (isOver: boolean) => void;
-    setContentPointerState: (isOver: boolean) => void;
-    isPointerInSystem: () => boolean;
-    getCssAnimation: () => boolean;
-    getCssOpeningAnimation: () => boolean;
-    getCssClosingAnimation: () => boolean;
-    constructor();
-    ngOnDestroy(): void;
-    onIndicatorTrackChange(track: HTMLElement | null): void;
-    onViewportChange(viewport: HTMLElement | null): void;
-    onTriggerEnter(itemValue: string): void;
-    onTriggerLeave(): void;
-    onContentEnter(): void;
-    onContentLeave(): void;
-    handleClose(): void;
-    onItemSelect(itemValue: string): void;
-    onItemDismiss(): void;
-    onViewportContentChange(contentValue: string, contentData: any): void;
-    onViewportContentRemove(contentValue: string): void;
-    private setValue;
-    private startCloseTimer;
-    private handleOpen;
-    private handleDelayedOpen;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxNavigationMenuDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxNavigationMenuDirective, "[rdxNavigationMenu]", ["rdxNavigationMenu"], { "orientation": { "alias": "orientation"; "required": false; }; "dir": { "alias": "dir"; "required": false; }; "clickIgnoreDuration": { "alias": "clickIgnoreDuration"; "required": false; }; "delayDuration": { "alias": "delayDuration"; "required": false; }; "skipDelayDuration": { "alias": "skipDelayDuration"; "required": false; }; "loop": { "alias": "loop"; "required": false; }; "cssAnimation": { "alias": "cssAnimation"; "required": false; }; "cssOpeningAnimation": { "alias": "cssOpeningAnimation"; "required": false; }; "cssClosingAnimation": { "alias": "cssClosingAnimation"; "required": false; }; }, {}, never, never, true, never>;
-    static ngAcceptInputType_clickIgnoreDuration: unknown;
-    static ngAcceptInputType_delayDuration: unknown;
-    static ngAcceptInputType_skipDelayDuration: unknown;
-    static ngAcceptInputType_loop: unknown;
-    static ngAcceptInputType_cssAnimation: unknown;
-    static ngAcceptInputType_cssOpeningAnimation: unknown;
-    static ngAcceptInputType_cssClosingAnimation: unknown;
+/**
+ * A registered item content template, rendered into the shared viewport when its item is active.
+ */
+interface RdxNavigationMenuContentEntry {
+    value: string;
+    contentId: string;
+    triggerId: string;
+    templateRef: TemplateRef<unknown>;
+    forceMount: Signal<boolean>;
 }
-
-declare class RdxNavigationMenuSubDirective {
-    readonly orientation: i0.InputSignal<"horizontal" | "vertical">;
-    set defaultValue(val: string);
-    readonly valueChange: i0.OutputEmitterRef<string>;
-    readonly value: i0.WritableSignal<string>;
-    readonly previousValue: i0.WritableSignal<string>;
+interface RdxNavigationMenuRootContext {
+    /** Whether this menu is nested inside another navigation menu's content. */
+    readonly nested: boolean;
     readonly baseId: string;
-    readonly isRootMenu = false;
-    private readonly parent;
-    get dir(): 'ltr' | 'rtl';
-    get rootNavigationMenu(): HTMLElement | null;
-    onTriggerEnter(itemValue: string): void;
-    onItemSelect(itemValue: string): void;
-    onItemDismiss(): void;
-    private setValue;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxNavigationMenuSubDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxNavigationMenuSubDirective, "[rdxNavigationMenuSub]", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+    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). */
+    readonly previousValue: Signal<string | null>;
+    readonly isOpen: Signal<boolean>;
+    readonly instant: Signal<boolean>;
+    readonly transitionStatus: Signal<RdxTransitionStatus>;
+    /** The active trigger element the popup is anchored to. */
+    readonly trigger: Signal<HTMLElement | undefined>;
+    readonly triggers: Signal<HTMLElement[]>;
+    readonly activeContent: Signal<RdxNavigationMenuContentEntry | undefined>;
+    contentId(value: string): string;
+    triggerId(value: string): string;
+    setValue(value: string | null, reason?: RdxNavigationMenuOpenChangeReason, event?: Event): void;
+    open(value: string, trigger: HTMLElement, reason?: RdxNavigationMenuOpenChangeReason, event?: Event): void;
+    close(reason?: RdxNavigationMenuOpenChangeReason, event?: Event): void;
+    toggle(value: string, trigger: HTMLElement, event?: Event): void;
+    openOnHover(value: string, trigger: HTMLElement, event: PointerEvent): void;
+    closeOnHover(): void;
+    cancelHoverOpen(): void;
+    cancelHoverClose(): void;
+    registerTrigger(value: string, trigger: HTMLElement): () => void;
+    registerContent(entry: RdxNavigationMenuContentEntry): () => void;
+    registerTransitionElement(element: HTMLElement): () => void;
+    registerViewport(onTriggerChange: (previous: HTMLElement, next: HTMLElement) => void): () => void;
 }
+declare const injectNavigationMenuRootContext: _radix_ng_primitives_core.InjectContext<RdxNavigationMenuRootContext>;
+declare const provideNavigationMenuRootContext: (useFactory: () => RdxNavigationMenuRootContext) => _angular_core.Provider;
 
-declare class RdxNavigationMenuItemDirective implements FocusableOption {
-    readonly elementRef: ElementRef<any>;
-    private readonly context;
-    readonly value: i0.InputSignal<string>;
+/**
+ * Groups all parts of the navigation menu.
+ *
+ * Holds the shared open state: `value` identifies the currently open item, and the menu is open
+ * whenever `value` is non-null. A single popup (Portal → Positioner → Popup → Viewport) is shared
+ * between every item and anchored to the active trigger.
+ */
+declare class RdxNavigationMenuRoot {
+    private readonly popper;
+    private readonly destroyRef;
+    private readonly parentRoot;
+    /** Whether this root is nested inside another navigation menu's content. */
+    readonly nested: boolean;
+    readonly baseId: string;
+    /**
+     * The value of the navigation menu item that should be currently open.
+     */
+    readonly value: _angular_core.ModelSignal<string | null>;
+    /**
+     * The uncontrolled value of the item that should be initially open.
+     */
+    readonly defaultValue: _angular_core.InputSignal<string | null>;
+    /**
+     * The orientation of the navigation menu.
+     */
+    readonly orientation: _angular_core.InputSignal<NavigationMenuOrientation>;
+    /**
+     * The reading direction of the navigation menu.
+     */
+    readonly dir: _angular_core.InputSignal<NavigationMenuDirection>;
     /**
-     * @ignore
+     * Whether keyboard navigation loops from the last item back to the first and vice versa.
      */
-    readonly triggerOrLink: Signal<RdxNavigationMenuFocusableOption | undefined>;
-    readonly triggerRef: i0.WritableSignal<HTMLElement | null>;
-    readonly contentRef: i0.WritableSignal<HTMLElement | null>;
-    readonly focusProxyRef: i0.WritableSignal<HTMLElement | null>;
-    readonly wasEscapeCloseRef: i0.WritableSignal<boolean>;
-    private readonly _restoreContentTabOrderRef;
-    get restoreContentTabOrderRef(): Signal<(() => void) | null>;
+    readonly loop: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /**
-     * Handle keyboard entry into content from trigger
+     * How long to wait before opening the menu on hover, in milliseconds.
      */
-    onEntryKeyDown(): void;
-    focus(): void;
+    readonly delay: _angular_core.InputSignalWithTransform<number, NumberInput>;
     /**
-     * Ensure elements are in the tab order by restoring any previously removed tabindex values
+     * How long to wait before closing the menu after the pointer leaves, in milliseconds.
      */
-    private ensureTabOrder;
+    readonly closeDelay: _angular_core.InputSignalWithTransform<number, NumberInput>;
     /**
-     * Handle focus coming from the focus proxy element
-     * @param side Which side the focus is coming from (start = from trigger, end = from after content)
+     * Emits when the open item changes.
      */
-    onFocusProxyEnter(side?: 'start' | 'end'): void;
+    readonly onValueChange: _angular_core.OutputEmitterRef<string | null>;
     /**
-     * Handle focus moving outside of the content
-     * Remove elements from tab order when not focused
+     * Emits whenever the menu opens or closes.
      */
-    onContentFocusOutside(): void;
+    readonly onOpenChange: _angular_core.OutputEmitterRef<RdxNavigationMenuOpenChange>;
     /**
-     * Handle content being closed from root menu
+     * Emits after any enter/exit transition completes.
      */
-    onRootContentClose(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxNavigationMenuItemDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxNavigationMenuItemDirective, "[rdxNavigationMenuItem]", ["rdxNavigationMenuItem"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, ["triggerOrLink"], never, true, never>;
+    readonly onOpenChangeComplete: _angular_core.OutputEmitterRef<boolean>;
+    private hasAppliedDefaultValue;
+    private openTimer;
+    private closeTimer;
+    private instantFrame;
+    private readonly transition;
+    readonly instant: _angular_core.WritableSignal<boolean>;
+    readonly transitionStatus: _angular_core.Signal<_radix_ng_primitives_core.RdxTransitionStatus>;
+    readonly previousValue: _angular_core.WritableSignal<string | null>;
+    readonly isOpen: _angular_core.Signal<boolean>;
+    readonly trigger: _angular_core.WritableSignal<HTMLElement | undefined>;
+    readonly triggers: _angular_core.WritableSignal<HTMLElement[]>;
+    readonly contents: _angular_core.WritableSignal<Map<string, RdxNavigationMenuContentEntry>>;
+    readonly activeContent: _angular_core.Signal<RdxNavigationMenuContentEntry | undefined>;
+    private readonly registeredTriggers;
+    private readonly viewportTriggerChange;
+    constructor();
+    contentId(value: string): string;
+    triggerId(value: string): string;
+    setValue(value: string | null, reason?: RdxNavigationMenuOpenChangeReason, event?: Event): void;
+    open(value: string, trigger: HTMLElement, reason?: RdxNavigationMenuOpenChangeReason, event?: Event): void;
+    close(reason?: RdxNavigationMenuOpenChangeReason, event?: Event): void;
+    toggle(value: string, trigger: HTMLElement, event?: Event): void;
+    openOnHover(value: string, trigger: HTMLElement, event: PointerEvent): void;
+    closeOnHover(): void;
+    cancelHoverOpen(): void;
+    cancelHoverClose(): void;
+    registerTrigger(value: string, trigger: HTMLElement): () => void;
+    registerContent(entry: RdxNavigationMenuContentEntry): () => void;
+    registerTransitionElement(element: HTMLElement): () => void;
+    registerViewport(onTriggerChange: (previous: HTMLElement, next: HTMLElement) => void): () => boolean;
+    private scheduleInstantReset;
+    private clearHoverTimers;
+    private clearOpenTimer;
+    private clearCloseTimer;
+    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; }; "dir": { "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: {}; }]>;
 }
 
-declare class RdxNavigationMenuListDirective implements AfterContentInit, AfterViewInit {
-    private readonly context;
-    private readonly elementRef;
-    private readonly renderer;
+/**
+ * Contains the navigation menu items. Renders as a menubar with roving keyboard focus.
+ */
+declare class RdxNavigationMenuList {
+    protected readonly rootContext: _radix_ng_primitives_navigation_menu.RdxNavigationMenuRootContext;
     private readonly rovingFocusGroup;
+    constructor();
+    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: {}; }]>;
+}
+
+/**
+ * A single navigation menu item. Holds a trigger + content pair, or a standalone link.
+ */
+declare class RdxNavigationMenuItem {
+    private readonly rootContext;
     /**
-     * @private
-     * @ignore
+     * A unique value that identifies the item. Falls back to a generated id.
      */
-    readonly items: i0.Signal<readonly any[]>;
+    readonly value: _angular_core.InputSignalWithTransform<string, string | undefined>;
+    /** The trigger element, set by the trigger directive. */
+    readonly triggerRef: _angular_core.WritableSignal<HTMLElement | null>;
+    /** Whether this item is the currently open one. */
+    readonly isOpen: _angular_core.Signal<boolean>;
+    readonly triggerId: _angular_core.Signal<string>;
+    readonly contentId: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNavigationMenuItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNavigationMenuItem, "[rdxNavigationMenuItem]", ["rdxNavigationMenuItem"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * A button that opens its item's content in the shared popup.
+ */
+declare class RdxNavigationMenuTrigger {
+    protected readonly item: RdxNavigationMenuItem;
+    private readonly rootContext;
+    private readonly rovingFocusItem;
+    private readonly elementRef;
+    private readonly document;
     /**
-     * @ignore
+     * Whether the trigger should ignore user interaction.
      */
-    protected keyManager: FocusKeyManager<RdxNavigationMenuItemDirective>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
-     * @ignore
+     * Whether the content should also open when the trigger is hovered.
      */
-    ngAfterContentInit(): void;
+    readonly openOnHover: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly open: _angular_core.Signal<boolean>;
+    constructor();
+    protected onClick(event: MouseEvent): void;
+    protected onPointerEnter(event: PointerEvent): void;
+    protected onPointerLeave(event: PointerEvent): void;
     /**
-     * @ignore
+     * 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.
      */
-    ngAfterViewInit(): void;
+    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: {}; }]>;
+}
+
+/**
+ * A visual indicator (e.g. a caret) rendered inside a trigger. Exposes the open state so the icon
+ * can rotate when its item opens.
+ */
+declare class RdxNavigationMenuIcon {
+    private readonly item;
+    protected readonly open: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNavigationMenuIcon, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNavigationMenuIcon, "[rdxNavigationMenuIcon]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * The content shown when its item is open. Used as a structural directive; its template is rendered
+ * into the shared {@link RdxNavigationMenuViewport}.
+ *
+ * ```html
+ * <ng-container *rdxNavigationMenuContent>…</ng-container>
+ * ```
+ */
+declare class RdxNavigationMenuContent {
+    private readonly rootContext;
+    private readonly item;
+    private readonly templateRef;
     /**
-     * @ignore
+     * Required by the structural directive syntax; the value is unused.
      */
-    onKeydown(event: Event): void;
+    readonly rdxNavigationMenuContent: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
-     * @ignore
+     * Keep the content mounted in the viewport even when its item is closed.
      */
-    setActiveItem(item: RdxNavigationMenuItemDirective): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxNavigationMenuListDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxNavigationMenuListDirective, "[rdxNavigationMenuList]", never, {}, {}, ["items"], never, true, [{ directive: typeof i1.RdxRovingFocusGroupDirective; inputs: {}; outputs: {}; }]>;
+    readonly forceMount: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNavigationMenuContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNavigationMenuContent, "[rdxNavigationMenuContent]", never, { "rdxNavigationMenuContent": { "alias": "rdxNavigationMenuContent"; "required": false; "isSignal": true; }; "forceMount": { "alias": "forceMount"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class RdxNavigationMenuTriggerDirective extends RdxNavigationMenuFocusableOption implements OnInit, OnDestroy {
-    protected readonly context: _radix_ng_primitives_navigation_menu.NavigationMenuContext;
-    private readonly item;
-    private readonly list;
-    private readonly rovingFocusItem;
+/**
+ * A navigation link. Closes the menu on selection unless prevented.
+ *
+ * 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.
+ */
+declare class RdxNavigationMenuLink {
+    private readonly rootContext;
     private readonly elementRef;
-    private readonly viewContainerRef;
-    readonly disabled: i0.InputSignalWithTransform<boolean, unknown>;
-    readonly openOnHover: i0.InputSignalWithTransform<boolean, unknown>;
-    readonly triggerId: string;
-    readonly contentId: string;
-    readonly open: i0.Signal<boolean>;
-    private focusProxyRef;
-    private ariaOwnsRef;
-    private hasPointerMoveOpened;
-    private wasClickClose;
-    constructor();
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    focus(): void;
-    private createAccessibilityComponents;
-    private removeAccessibilityComponents;
-    onPointerEnter(): void;
-    onPointerMove(event: Event): void;
-    onPointerLeave(event: Event): void;
-    onClick(): void;
-    onKeydown(event: Event): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxNavigationMenuTriggerDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxNavigationMenuTriggerDirective, "[rdxNavigationMenuTrigger]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "openOnHover": { "alias": "openOnHover"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.RdxRovingFocusItemDirective; inputs: {}; outputs: {}; }]>;
+    /**
+     * Whether the link represents the current page.
+     */
+    readonly active: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether selecting the link should close the menu.
+     */
+    readonly closeOnClick: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Emits when the link is selected. Call `preventDefault()` to keep the menu open.
+     */
+    readonly onSelect: _angular_core.OutputEmitterRef<Event>;
+    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>;
 }
 
-declare class RdxNavigationMenuLinkDirective extends RdxNavigationMenuFocusableOption implements OnInit {
-    private readonly rovingFocusItem;
-    private readonly uniqueId;
-    readonly active: i0.InputSignalWithTransform<boolean, unknown>;
-    readonly onSelect: i0.InputSignal<((event: Event) => void) | undefined>;
-    readonly elementRef: ElementRef<any>;
-    ngOnInit(): void;
-    focus(): void;
-    onClick(event: Event): void;
-    onKeydown(event: Event): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxNavigationMenuLinkDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxNavigationMenuLinkDirective, "[rdxNavigationMenuLink]", never, { "active": { "alias": "active"; "required": false; "isSignal": true; }; "onSelect": { "alias": "onSelect"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.RdxRovingFocusItemDirective; inputs: { "focusable": "focusable"; }; outputs: {}; }]>;
+/**
+ * Moves the navigation menu popup to a different part of the DOM (by default `document.body`).
+ */
+declare class RdxNavigationMenuPortal {
+    protected readonly rootContext: _radix_ng_primitives_navigation_menu.RdxNavigationMenuRootContext;
+    /**
+     * Optional container to portal the popup into. Defaults to `document.body`.
+     */
+    readonly container: _angular_core.InputSignal<RdxPortalContainer | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNavigationMenuPortal, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNavigationMenuPortal, "[rdxNavigationMenuPortal]", never, { "container": { "alias": "container"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$3.RdxPortal; inputs: { "container": "container"; }; outputs: {}; }]>;
+}
+
+/**
+ * An optional backdrop rendered behind the popup.
+ */
+declare class RdxNavigationMenuBackdrop {
+    protected readonly rootContext: _radix_ng_primitives_navigation_menu.RdxNavigationMenuRootContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNavigationMenuBackdrop, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNavigationMenuBackdrop, "[rdxNavigationMenuBackdrop]", never, {}, {}, never, never, true, never>;
 }
 
-declare class RdxNavigationMenuIndicatorDirective implements OnDestroy {
-    protected readonly context: _radix_ng_primitives_navigation_menu.NavigationMenuContext;
+/**
+ * Positions the shared popup against the active trigger.
+ */
+declare class RdxNavigationMenuPositioner {
+    protected readonly rootContext: _radix_ng_primitives_navigation_menu.RdxNavigationMenuRootContext;
+    protected readonly wrapper: RdxPopperContentWrapper;
     private readonly elementRef;
-    private readonly renderer;
+    private readonly triggerEl;
+    private readonly containerEl;
+    private readonly graceArea;
+    /**
+     * An element to position the popup against. Defaults to the active 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<"start" | "center" | "end">;
+    /**
+     * 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>;
     /**
-     * Used to keep the indicator rendered and available in the DOM, even when hidden.
-     * Useful for animations.
-     * @default false
-     */
-    readonly forceMount: i0.InputSignalWithTransform<boolean, unknown>;
-    /** @ignore */
-    private readonly _position;
-    /** @ignore */
-    private readonly _activeTrigger;
-    /** @ignore */
-    private readonly _resizeObserver;
-    readonly isVisible: i0.Signal<boolean>;
+     * 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">;
     constructor();
-    /** @ignore */
-    ngOnDestroy(): void;
-    /** @ignore */
-    private findAndSetActiveTrigger;
-    /** @ignore */
-    private updatePosition;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxNavigationMenuIndicatorDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxNavigationMenuIndicatorDirective, "[rdxNavigationMenuIndicator]", never, { "forceMount": { "alias": "forceMount"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNavigationMenuPositioner, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNavigationMenuPositioner, "[rdxNavigationMenuPositioner]", never, { "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; }; }, {}, never, never, true, [{ directive: typeof i1$1.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: {}; }]>;
 }
 
-declare class RdxNavigationMenuContentDirective implements OnInit, OnDestroy {
+/**
+ * The shared container for the active item's content.
+ */
+declare class RdxNavigationMenuPopup {
+    protected readonly rootContext: _radix_ng_primitives_navigation_menu.RdxNavigationMenuRootContext;
+    private readonly dismissableLayer;
+    private readonly wrapper;
+    private readonly layersContext;
     private readonly elementRef;
-    private readonly ngZone;
-    private readonly template;
-    private readonly document;
-    private readonly item;
-    private readonly context;
-    set rdxNavigationMenuContent(value: boolean);
-    /**
-     * Used to keep the content rendered and available in the DOM, even when closed.
-     * Useful for animations or SEO.
-     * @default false
-     */
-    readonly forceMount: i0.InputSignalWithTransform<boolean, unknown>;
-    /** @ignore */
-    readonly contentId: string;
-    /** @ignore */
-    readonly triggerId: string;
-    private escapeHandler;
-    /** @ignore */
-    ngOnInit(): void;
-    /** @ignore */
-    ngOnDestroy(): void;
-    /** @ignore - Compute motion attribute for animations */
-    getMotionAttribute(): string | null;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxNavigationMenuContentDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxNavigationMenuContentDirective, "[rdxNavigationMenuContent]", never, { "rdxNavigationMenuContent": { "alias": "rdxNavigationMenuContent"; "required": false; }; "forceMount": { "alias": "forceMount"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-    static ngAcceptInputType_rdxNavigationMenuContent: unknown;
+    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>;
+    private dismissReason;
+    private dismissEvent;
+    /**
+     * Event handler called when the escape key is down. Can be prevented.
+     */
+    readonly escapeKeyDown: _angular_core.OutputRef<KeyboardEvent>;
+    /**
+     * Event handler called when a pointerdown event happens outside the popup. Can be prevented.
+     */
+    readonly pointerDownOutside: _angular_core.OutputRef<PointerEvent>;
+    /**
+     * Event handler called when focus moves outside the popup. Can be prevented.
+     */
+    readonly focusOutside: _angular_core.OutputRef<FocusEvent>;
+    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 dismissable layer.)
+     */
+    protected onKeydown(event: KeyboardEvent): void;
+    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: {}; }, { directive: typeof i2.RdxDismissableLayer; inputs: {}; outputs: {}; }]>;
 }
 
-declare class RdxNavigationMenuViewportDirective implements OnInit, OnDestroy {
-    protected readonly context: _radix_ng_primitives_navigation_menu.NavigationMenuContext;
-    private readonly document;
-    private readonly window;
+/**
+ * An optional arrow element pointing toward the active trigger.
+ */
+declare class RdxNavigationMenuArrow {
+    protected readonly rootContext: _radix_ng_primitives_navigation_menu.RdxNavigationMenuRootContext;
+    private readonly wrapper;
+    protected readonly side: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    protected readonly align: _angular_core.Signal<"start" | "center" | "end" | undefined>;
+    protected readonly uncentered: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNavigationMenuArrow, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNavigationMenuArrow, "[rdxNavigationMenuArrow]", never, {}, {}, never, never, true, [{ directive: typeof i1$1.RdxPopperArrow; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Clips and animates the active item's content. A single viewport is shared between all items; when
+ * the active item changes the outgoing content is retained as `data-previous` until its CSS
+ * animation/transition completes, and the new content is marked `data-current`.
+ */
+declare class RdxNavigationMenuViewport {
+    protected readonly rootContext: _radix_ng_primitives_navigation_menu.RdxNavigationMenuRootContext;
     private readonly elementRef;
     private readonly viewContainerRef;
     private readonly renderer;
-    private readonly zone;
-    private readonly destroyRef;
     /**
-     * Used to keep the viewport rendered and available in the DOM, even when closed.
-     * Useful for animations.
-     * @default false
-     */
-    readonly forceMount: i0.InputSignalWithTransform<boolean, unknown>;
-    private readonly _contentNodes;
-    private readonly _activeContentNode;
-    private readonly _leavingContentNode;
-    private readonly _viewportSize;
-    readonly activeContentValue: i0.Signal<string | null>;
-    readonly isOpen: i0.Signal<boolean>;
-    readonly dataState: i0.Signal<"open" | "closed">;
-    readonly viewportSize: i0.Signal<{
+     * Keep the viewport mounted even when the menu is closed.
+     */
+    readonly forceMount: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly activationDirection: _angular_core.WritableSignal<string | undefined>;
+    protected readonly transitioning: _angular_core.WritableSignal<boolean>;
+    protected readonly size: _angular_core.WritableSignal<{
         width: number;
         height: number;
     } | null>;
-    private readonly _resizeObserver;
+    private current;
+    private previousElement;
+    private pendingDirection;
+    private cleanupTimer;
+    private readonly resizeObserver;
+    private readonly activeContent;
     constructor();
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    onKeydown(event: Event): void;
-    onPointerEnter(): void;
-    onPointerLeave(): void;
-    private setupViewportEffect;
-    private getOrCreateContentNode;
-    private addNodeToDOM;
-    private removeNodeFromDOM;
-    private setNodeState;
-    private applyA11yAttributes;
-    private startLeaveTransition;
-    /**
-     * Cleanup function called after leave animation finishes
-     * @param node The node that is leaving
-     */
-    private cleanupAfterLeave;
-    /**
-     * Cancels an ongoing leave transition (e.g., if user hovers back)
-     * @param node The node that is leaving
-     */
-    private cancelLeaveTransition;
-    /**
-     * Force completes a leave transition (e.g., if another leave starts)
-     * @param node The node that is leaving
-     */
-    private forceCompleteLeaveTransition;
-    private updateSize;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxNavigationMenuViewportDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxNavigationMenuViewportDirective, "[rdxNavigationMenuViewport]", never, { "forceMount": { "alias": "forceMount"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-declare class RdxNavigationMenuFocusProxyComponent {
-    triggerElement: HTMLElement | null;
-    contentElement: HTMLElement | null;
-    proxyFocus: EventEmitter<"start" | "end">;
-    onFocus(event: Event): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxNavigationMenuFocusProxyComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<RdxNavigationMenuFocusProxyComponent, "rdx-navigation-menu-focus-proxy", never, { "triggerElement": { "alias": "triggerElement"; "required": false; }; "contentElement": { "alias": "contentElement"; "required": false; }; }, { "proxyFocus": "proxyFocus"; }, never, never, true, never>;
-}
-declare class RdxNavigationMenuAriaOwnsComponent {
-    contentId: string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxNavigationMenuAriaOwnsComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<RdxNavigationMenuAriaOwnsComponent, "rdx-navigation-menu-aria-owns", never, { "contentId": { "alias": "contentId"; "required": false; }; }, {}, never, never, true, never>;
-}
-
-interface NavigationMenuContext {
-    isRootMenu: boolean;
-    value: () => string;
-    previousValue: () => string;
-    baseId: string;
-    dir: 'ltr' | 'rtl';
-    orientation: 'horizontal' | 'vertical';
-    loop: boolean;
-    rootNavigationMenu: () => HTMLElement | null;
-    indicatorTrack?: () => HTMLElement | null;
-    onIndicatorTrackChange?: (track: HTMLElement | null) => void;
-    userDismissedByClick?: () => boolean;
-    resetUserDismissed?: () => void;
-    viewport?: () => HTMLElement | null;
-    onViewportChange?: (viewport: HTMLElement | null) => void;
-    viewportContent?: () => Map<string, any>;
-    onViewportContentChange?: (contentValue: string, contentData: any) => void;
-    onViewportContentRemove?: (contentValue: string) => void;
-    onTriggerEnter?: (itemValue: string) => void;
-    onTriggerLeave?: () => void;
-    onContentEnter?: () => void;
-    onContentLeave?: () => void;
-    onItemSelect?: (itemValue: string) => void;
-    onItemDismiss?: () => void;
-    handleClose?: (force?: boolean) => void;
-    setTriggerPointerState?: (isOver: boolean) => void;
-    setContentPointerState?: (isOver: boolean) => void;
-    isPointerInSystem?: () => boolean;
+    private render;
+    private startLeave;
+    private removePrevious;
+    private clearCleanupTimer;
+    private measure;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNavigationMenuViewport, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNavigationMenuViewport, "[rdxNavigationMenuViewport]", never, { "forceMount": { "alias": "forceMount"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
-declare const RDX_NAVIGATION_MENU_TOKEN: InjectionToken<NavigationMenuContext>;
-declare function injectNavigationMenu(): NavigationMenuContext;
-declare function isRootNavigationMenu(context: NavigationMenuContext): boolean;
-declare function provideNavigationMenuContext(provider: Type<RdxNavigationMenuDirective | RdxNavigationMenuSubDirective>): Provider;
 
+declare const navigationMenuImports: (typeof RdxNavigationMenuPortalPresence)[];
 declare class RdxNavigationMenuModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxNavigationMenuModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxNavigationMenuModule, never, [typeof RdxNavigationMenuDirective, typeof RdxNavigationMenuSubDirective, typeof RdxNavigationMenuListDirective, typeof RdxNavigationMenuItemDirective, typeof RdxNavigationMenuTriggerDirective, typeof RdxNavigationMenuLinkDirective, typeof RdxNavigationMenuIndicatorDirective, typeof RdxNavigationMenuContentDirective, typeof RdxNavigationMenuViewportDirective, typeof RdxNavigationMenuFocusProxyComponent, typeof RdxNavigationMenuAriaOwnsComponent], [typeof RdxNavigationMenuDirective, typeof RdxNavigationMenuSubDirective, typeof RdxNavigationMenuListDirective, typeof RdxNavigationMenuItemDirective, typeof RdxNavigationMenuTriggerDirective, typeof RdxNavigationMenuLinkDirective, typeof RdxNavigationMenuIndicatorDirective, typeof RdxNavigationMenuContentDirective, typeof RdxNavigationMenuViewportDirective, typeof RdxNavigationMenuFocusProxyComponent, typeof RdxNavigationMenuAriaOwnsComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<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 RdxNavigationMenuPortalPresence, 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 RdxNavigationMenuPortalPresence, typeof RdxNavigationMenuBackdrop, typeof RdxNavigationMenuPositioner, typeof RdxNavigationMenuPopup, typeof RdxNavigationMenuArrow, typeof RdxNavigationMenuViewport]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<RdxNavigationMenuModule>;
 }
 
-export { RDX_NAVIGATION_MENU_TOKEN, RdxNavigationMenuAction, RdxNavigationMenuAnimationStatus, RdxNavigationMenuAriaOwnsComponent, RdxNavigationMenuContentDirective, RdxNavigationMenuDirective, RdxNavigationMenuFocusProxyComponent, RdxNavigationMenuFocusableOption, RdxNavigationMenuIndicatorDirective, RdxNavigationMenuItemDirective, RdxNavigationMenuLinkDirective, RdxNavigationMenuListDirective, RdxNavigationMenuModule, RdxNavigationMenuSubDirective, RdxNavigationMenuTriggerDirective, RdxNavigationMenuViewportDirective, injectNavigationMenu, isRootNavigationMenu, provideNavigationMenuContext };
-export type { NavigationMenuContext };
+export { RdxNavigationMenuArrow, RdxNavigationMenuBackdrop, RdxNavigationMenuContent, RdxNavigationMenuIcon, RdxNavigationMenuItem, RdxNavigationMenuLink, RdxNavigationMenuList, RdxNavigationMenuModule, RdxNavigationMenuPopup, RdxNavigationMenuPortal, RdxNavigationMenuPortalPresence, RdxNavigationMenuPositioner, RdxNavigationMenuRoot, RdxNavigationMenuTrigger, RdxNavigationMenuViewport, injectNavigationMenuRootContext, navigationMenuImports, provideNavigationMenuRootContext };
+export type { NavigationMenuDirection, NavigationMenuOrientation, RdxNavigationMenuContentEntry, RdxNavigationMenuOpenChange, RdxNavigationMenuOpenChangeReason, RdxNavigationMenuRootContext };