@radix-ng/primitives 0.50.0 → 1.0.0-beta.0

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

@@ -0,0 +1,488 @@
+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';
+
+/**
+ * Mounts the popup while the menu is open and waits for CSS exit keyframes before unmounting.
+ *
+ * ```html
+ * <ng-template rdxNavigationMenuPortalPresence>…</ng-template>
+ * ```
+ */
+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: {}; }]>;
+}
+
+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;
+}
+/**
+ * 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>;
+}
+interface RdxNavigationMenuRootContext {
+    /** Whether this menu is nested inside another navigation menu's content. */
+    readonly nested: boolean;
+    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). */
+    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: (optional?: boolean) => RdxNavigationMenuRootContext | null;
+declare const provideNavigationMenuRootContext: (useFactory: () => RdxNavigationMenuRootContext) => _angular_core.Provider;
+
+/**
+ * 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>;
+    /**
+     * 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.
+     */
+    readonly delay: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * How long to wait before closing the menu after the pointer leaves, in milliseconds.
+     */
+    readonly closeDelay: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * Emits when the open item changes.
+     */
+    readonly onValueChange: _angular_core.OutputEmitterRef<string | null>;
+    /**
+     * Emits whenever the menu opens or closes.
+     */
+    readonly onOpenChange: _angular_core.OutputEmitterRef<RdxNavigationMenuOpenChange>;
+    /**
+     * Emits after any enter/exit transition completes.
+     */
+    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: {}; }]>;
+}
+
+/**
+ * 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;
+    /**
+     * A unique value that identifies the item. Falls back to a generated id.
+     */
+    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;
+    /**
+     * Whether the trigger should ignore user interaction.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether the content should also open when the trigger is hovered.
+     */
+    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;
+    /**
+     * 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: {}; }]>;
+}
+
+/**
+ * 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;
+    /**
+     * Required by the structural directive syntax; the value is unused.
+     */
+    readonly rdxNavigationMenuContent: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Keep the content mounted in the viewport even when its item is closed.
+     */
+    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>;
+}
+
+/**
+ * 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;
+    /**
+     * 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>;
+}
+
+/**
+ * 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>;
+}
+
+/**
+ * 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 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>;
+    /**
+     * 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();
+    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: {}; }]>;
+}
+
+/**
+ * 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;
+    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: {}; }]>;
+}
+
+/**
+ * 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;
+    /**
+     * 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 current;
+    private previousElement;
+    private pendingDirection;
+    private cleanupTimer;
+    private readonly resizeObserver;
+    private readonly activeContent;
+    constructor();
+    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 navigationMenuImports: (typeof RdxNavigationMenuPortalPresence)[];
+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 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 { 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 };