import * as _angular_core from '@angular/core';
import { InjectionToken, Signal, Provider } from '@angular/core';
import { WritingDirection, ListNavigationAction, CollectionHandle } from 'forty-cdk/core';
import * as forty_cdk_navigation_menu from 'forty-cdk/navigation-menu';

/**
 * Per-trigger handle stored in the menu's `Collection`. Triggers register
 * themselves on construction so the menu can run roving-tabindex and
 * arrow-key navigation in DOM order.
 *
 * Part of the registration protocol, so it is never exported from
 * `public-api.ts` — see {@link NavigationMenuContext}.
 */
interface ForNavigationMenuTriggerHandle extends CollectionHandle {
    /**
     * Narrowed from {@link CollectionHandle}'s `Node`: the menu focuses the
     * trigger, scrolls it into view, and measures it for indicator positioning.
     */
    readonly host: HTMLElement;
    readonly value: Signal<string>;
    readonly disabled: Signal<boolean>;
    readonly id: Signal<string>;
}
/**
 * Per-content handle stored in the menu's `Collection` for trigger ↔ content
 * wiring. Part of the registration protocol, so it is never exported from
 * `public-api.ts` — see {@link NavigationMenuContext}.
 */
interface ForNavigationMenuContentHandle extends CollectionHandle {
    /**
     * Narrowed from {@link CollectionHandle}'s `Node`: the active panel's host is
     * measured for viewport sizing and counted as a dismiss-exempt surface.
     */
    readonly host: HTMLElement;
    readonly value: Signal<string>;
    readonly id: Signal<string>;
}
/**
 * Per-viewport handle. Only one viewport is expected per menu. The host
 * element is the destination for re-parented active
 * content panels, and the viewport owns their ordering.
 *
 * Part of the registration protocol, so it is never exported from
 * `public-api.ts` — see {@link NavigationMenuContext}.
 */
interface ForNavigationMenuViewportHandle {
    readonly host: HTMLElement;
    /**
     * Re-parent `panel` into the viewport host at the position dictated by
     * its `triggerHost`'s document order, so the panels' DOM order always
     * matches trigger order regardless of mount timing. This makes the
     * entering/leaving overlap during an animated A→B transition
     * deterministic: a panel whose trigger precedes another's is always
     * inserted before it, never appended last just because it mounted later.
     *
     * No-op when the panel is already correctly placed. `triggerHost` may be
     * `null` (trigger not yet registered); the panel is then appended last.
     */
    insertPanel(panel: HTMLElement, triggerHost: HTMLElement | null): void;
}
/**
 * Logical motion direction for `[forNavigationMenuContent]`'s
 * `data-motion` hook, computed from the relative DOM position of the
 * previously- and currently-active triggers. `null` (attribute absent)
 * when no comparison applies — first open, last close, or unknown values.
 */
type ForNavigationMenuMotion = 'from-start' | 'from-end' | 'to-start' | 'to-end';
/** Read surface `[forNavigationMenu]` publishes through {@link FOR_NAVIGATION_MENU_CONTEXT}. */
interface ForNavigationMenuContext {
    /**
     * The open item's value, or `null` for none, as a read-only signal. Mutate it
     * through `open` / `close` / `toggle` or the root's `[(value)]` binding — a
     * direct write would skip the scheduled open / close delays.
     */
    readonly value: Signal<string | null>;
    readonly orientation: Signal<'horizontal' | 'vertical'>;
    readonly dir: Signal<WritingDirection>;
    readonly loop: Signal<boolean>;
    readonly disabled: Signal<boolean>;
    isOpen(value: string): boolean;
    /** Toggle the open item (open if closed, close if currently open). */
    toggle(value: string): void;
    /** Open the given item (no-op if already open). */
    open(value: string): void;
    /** Close any open item. */
    close(): void;
    /**
     * Schedule open / close with the configured delays. Keyboard-driven changes
     * (`reason`) skip the delays.
     */
    scheduleOpen(value: string, reason: NavigationMenuScheduleReason): void;
    /**
     * Schedule a hover close. Pass the leaving trigger's `value` so a quick
     * hover-then-leave on a still-closed trigger cancels its own pending open;
     * a pending open for a sibling (hover-across) is left to take over.
     */
    scheduleClose(reason: NavigationMenuScheduleReason, value?: string): void;
    cancelPending(): void;
    navigate(currentTrigger: HTMLElement, action: ListNavigationAction): void;
    /** Focus the trigger associated with the given value, if any. */
    focusTrigger(value: string): void;
    /**
     * Looks up the content id for a given item value. Reactive.
     *
     * Triggers and contents register synchronously in their constructors, so the
     * pairing resolves during the first change-detection pass — including a real
     * server render, where `afterNextRender` never fires and a deferred
     * registration left the pre-hydration DOM without its `aria-controls` /
     * `aria-labelledby` linkage. A handle whose owning `[forNavigationMenuItem]`
     * has not had its `[value]` written yet reads the `unsetInput` sentinel and is
     * skipped — it can never pair with a lookup value — and the tracked dependency
     * re-runs the lookup once that binding lands.
     */
    contentIdFor(value: string): string | null;
    /**
     * Looks up the trigger id for a given item value. Reactive. Same
     * synchronous-registration and not-yet-bound handling as
     * {@link contentIdFor}.
     */
    triggerIdFor(value: string): string | null;
    /**
     * Looks up the trigger host element for a given item value. Reactive. Same
     * synchronous-registration and not-yet-bound handling as
     * {@link contentIdFor}.
     */
    triggerHostFor(value: string): HTMLElement | null;
    /** Layout-oriented selector for indicator positioning. */
    readonly activeTriggerHost: Signal<HTMLElement | null>;
    /** Host element of the currently-active content, if any. */
    readonly activeContentHost: Signal<HTMLElement | null>;
    /** Most recent open value before the current one. `null` if none. */
    readonly previousValue: Signal<string | null>;
    /**
     * Motion direction for `[forNavigationMenuContent]` whose item carries
     * `value`. Returns `null` when no transition applies (first open, value
     * not currently entering or leaving, indices unknown).
     */
    motionFor(value: string): ForNavigationMenuMotion | null;
}
type NavigationMenuScheduleReason = 'hover' | 'keyboard' | 'click';
/**
 * The navigation menu's internal coordination surface: everything
 * {@link ForNavigationMenuContext} publishes plus the piece-registration
 * protocol and the surface-level focus delegation.
 *
 * Never exported from `public-api.ts`. It is the type the pieces read
 * {@link FOR_NAVIGATION_MENU_CONTEXT} at, so a consumer who injects that token
 * gets the read surface while the pieces get the wiring protocol.
 * `ForNavigationMenu` declares the protocol members TS-`private` / `protected`,
 * which keeps them out of the emitted `.d.ts` while `useExisting` still
 * satisfies this contract at runtime.
 */
interface NavigationMenuContext extends ForNavigationMenuContext {
    registerTrigger(handle: ForNavigationMenuTriggerHandle): void;
    unregisterTrigger(handle: ForNavigationMenuTriggerHandle): void;
    registerContent(handle: ForNavigationMenuContentHandle): void;
    unregisterContent(handle: ForNavigationMenuContentHandle): void;
    registerViewport(handle: ForNavigationMenuViewportHandle): void;
    unregisterViewport(handle: ForNavigationMenuViewportHandle): void;
    /** Currently-registered viewport (at most one), or `null`. */
    readonly viewport: Signal<ForNavigationMenuViewportHandle | null>;
    /**
     * Route a `focusout` observed anywhere on the widget's surface to the root,
     * which acts on it only when the leave reports no destination
     * (`relatedTarget === null`) — every other leave is owned by the dismissible
     * layer's `'focus'` channel. `[forNavigationMenuContent]` delegates its own
     * host's `focusout` here so such a leave is visible to the root even when a
     * `[forNavigationMenuViewport]` re-parented the panel outside the `<nav>`.
     */
    handleSurfaceFocusOut(event: FocusEvent): void;
}
/** Per-item context, consumed by the trigger and content. */
interface ForNavigationMenuItemContext {
    /**
     * The item's id, matched against the menu's `value`. Reads the `unsetInput`
     * sentinel until the consumer's `[value]` binding is written — the root's
     * lookups skip a handle in that state rather than throwing, which is what lets
     * the trigger and content register synchronously. Guard with `isUnset` before
     * letting the value leave a read site.
     */
    readonly value: Signal<string>;
    /**
     * The item's own `[disabled]`, without the root `[forNavigationMenu]`'s
     * `disabled` folded in. The trigger composes the two into its
     * `effectiveDisabled`.
     */
    readonly disabled: Signal<boolean>;
}
/**
 * DI token for the navigation menu's coordination surface, provided by
 * `[forNavigationMenu]`.
 *
 * Publicly typed as the read surface {@link ForNavigationMenuContext}, which is the whole
 * of what the token promises a consumer. The pieces read the same token at an internal type
 * that adds the registration protocol, so a wrapper re-providing it must alias it to the
 * root: `{ provide: FOR_NAVIGATION_MENU_CONTEXT, useExisting: MyNavigationMenu }`, where
 * `MyNavigationMenu` extends `ForNavigationMenu`. A value that merely satisfies the declared
 * type resolves too, and is rejected in dev mode by the first piece to reach the protocol.
 */
declare const FOR_NAVIGATION_MENU_CONTEXT: InjectionToken<ForNavigationMenuContext>;
declare const FOR_NAVIGATION_MENU_ITEM_CONTEXT: InjectionToken<ForNavigationMenuItemContext>;

/**
 * Headless implementation of the
 * [WAI-ARIA Disclosure Navigation Menu pattern](https://www.w3.org/WAI/ARIA/apg/patterns/disclosure/examples/disclosure-navigation/).
 *
 * Despite the name, this is a `<nav>` of disclosures — NOT an ARIA `menu`.
 * Triggers are buttons with `aria-expanded`, content is regular landmarks
 * with links inside; Tab moves through links; Escape closes the open item
 * and returns focus to its trigger.
 *
 * One item is open at a time. Selection is exposed as `value` (the open
 * item's id, or `null` when nothing is open). The `model()` change emitter
 * fires only on internal transitions, never on consumer writes.
 *
 * Nested submenus are out of scope for v1.
 *
 * @example
 * ```html
 * <nav forNavigationMenu aria-label="Main">
 *   <ul forNavigationMenuList>
 *     <li forNavigationMenuItem value="products">
 *       <button forNavigationMenuTrigger>Products</button>
 *       @if (products.isOpen()) {
 *         <div forNavigationMenuContent>…</div>
 *       }
 *     </li>
 *   </ul>
 * </nav>
 * ```
 */
declare class ForNavigationMenu implements ForNavigationMenuContext {
    #private;
    /**
     * Two-way bindable. The id of the open item, or `null` for none. The
     * `model()` change emitter (`(valueChange)`) fires only on internal
     * transitions (trigger click, hover delay, Escape, outside click), never
     * on consumer writes via `[(value)]`.
     */
    readonly value: _angular_core.ModelSignal<string | null>;
    /**
     * Axis the arrow keys navigate between triggers. Reflected as `data-orientation`.
     */
    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
    /**
     * Writing direction. When unset (default `null`), the inherited ambient
     * direction is resolved from the nearest ancestor carrying a `dir` attribute
     * (or `<html dir>`), defaulting to `'ltr'`. An explicit `[dir]` always wins.
     * The resolved value is reflected to the host `dir` attribute and swaps
     * ArrowLeft / ArrowRight semantics in RTL.
     */
    readonly _dirInput: _angular_core.InputSignal<WritingDirection | null>;
    readonly dir: Signal<WritingDirection>;
    /**
     * Whether arrow navigation wraps past the first / last enabled trigger.
     */
    readonly loop: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Whether every item in the navigation is disabled, so no panel can be opened.
     */
    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Manual `aria-label` for the surrounding `<nav>`. Use this when no visible
     * label element exists; otherwise prefer pointing `aria-labelledby` at one.
     * A `null` (default) or empty value emits no attribute.
     */
    readonly ariaLabel: _angular_core.InputSignal<string | null>;
    protected readonly resolvedAriaLabel: Signal<string | null>;
    /**
     * ms before a hover opens an item. Default `200`. The default is read from
     * `provideForNavigationMenuDefaults` for the surrounding scope.
     */
    readonly openDelay: _angular_core.InputSignal<number>;
    /**
     * ms before an item closes after hover leaves. Default `150`. The default
     * is read from `provideForNavigationMenuDefaults` for the surrounding
     * scope.
     */
    readonly closeDelay: _angular_core.InputSignal<number>;
    /**
     * ms after a peer item closed during which the next open is instant.
     * Keeps fluid hover-across-triggers feeling responsive. Default `300`.
     * The default is read from `provideForNavigationMenuDefaults` for the
     * surrounding scope.
     */
    readonly skipDelayDuration: _angular_core.InputSignal<number>;
    /** The `value` that was open before the current one, or `null`. */
    readonly previousValue: _angular_core.WritableSignal<string | null>;
    constructor();
    isOpen(value: string): boolean;
    toggle(value: string): void;
    /**
     * Opens the item with the given `value` and arms the dismissible layer.
     *
     * The layer owns both outside-interaction channels: `'pointer'` for an
     * outside pointerdown and `'focus'` for a focus move landing outside the
     * widget. The `'focus'` channel is what makes the APG close-on-leave rule
     * work from anywhere in the widget rather than only from the trigger row — it
     * observes `focusin` on the document, so it also fires for a panel that a
     * `[forNavigationMenuViewport]` re-parented outside the `<nav>`, whose
     * `focusout` never bubbles to the nav host. It is also the sole owner of every
     * leave that reports a destination, which is what keeps the widget's
     * containment rule single ({@link handleSurfaceFocusOut}). Both channels treat
     * the nav host, the registered viewport and the active panel — plus any layer
     * stacked above them — as inside, and the layer reports a press it resolved as
     * *inside* that same set through `onPointerDownInside` — the one input
     * {@link handleSurfaceFocusOut} needs to tell a pointer-induced blur from
     * focus leaving the document.
     */
    open(value: string): void;
    close(): void;
    scheduleOpen(value: string, reason: NavigationMenuScheduleReason): void;
    scheduleClose(reason: NavigationMenuScheduleReason, value?: string): void;
    cancelPending(): void;
    /**
     * Closes any open dropdown when focus leaves the navigation, per APG.
     *
     * Every leave that reports a destination is owned by the dismissible layer's `'focus'` channel
     * and returns from here untouched, so "did focus leave the widget?" has one owner.
     *
     * This handler covers only the leave the layer cannot see: a `null` `relatedTarget`, which fires
     * no `focusin` at all — focus leaving the document, or landing on a non-focusable area. It runs
     * on both the nav host and `[forNavigationMenuContent]`, since a `focusout` inside a panel
     * re-parented by `[forNavigationMenuViewport]` never bubbles to the `<nav>`.
     *
     * Because a `null` `relatedTarget` says nothing about where focus went, the decision is deferred
     * one microtask and taken against `document.activeElement` once focus has settled.
     *
     * Focus landing on `<body>` is ambiguous — it looks the same whether the user tabbed out of the
     * document or pressed a non-focusable region inside the widget. The layer resolves that press
     * against the same containment set and reports it through `onPointerDownInside`, so a
     * pointer-induced blur does not dismiss a panel the user is still interacting with.
     */
    protected handleSurfaceFocusOut(event: FocusEvent): void;
    navigate(currentTrigger: HTMLElement, action: ListNavigationAction): void;
    focusTrigger(value: string): void;
    private registerTrigger;
    private unregisterTrigger;
    private registerContent;
    private unregisterContent;
    private registerViewport;
    private unregisterViewport;
    private readonly viewport;
    contentIdFor(value: string): string | null;
    triggerIdFor(value: string): string | null;
    triggerHostFor(value: string): HTMLElement | null;
    /** Layout-oriented selectors for indicator positioning. */
    readonly activeTriggerHost: Signal<HTMLElement | null>;
    /** Currently-active content's host element, if mounted. */
    readonly activeContentHost: Signal<HTMLElement | null>;
    /**
     * `data-motion` direction for the content with the given `value`, so entering and leaving panels
     * shift in the same logical direction like a carousel advancing.
     *
     * - The entering content reflects `from-start` / `from-end`, based on which side the previous
     *   trigger sat on relative to it.
     * - A leaving content reflects `to-start` / `to-end`, frozen at the transition that started its
     *   exit and stable for as long as the panel stays mounted, so overlapping `animate.leave`
     *   transitions never lose a panel's direction.
     * - Anything else returns `null` and the host emits no attribute, including the first open and
     *   last close, where there is no peer to compare against.
     *
     * "Start" and "end" are logical — index 0 in DOM order is start, which is visually on the right
     * under `dir="rtl"` — so keyframes authored with logical CSS flip automatically.
     */
    motionFor(value: string): ForNavigationMenuMotion | null;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForNavigationMenu, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForNavigationMenu, "[forNavigationMenu]", ["forNavigationMenu"], { "value": { "alias": "value"; "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; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "openDelay": { "alias": "openDelay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; "skipDelayDuration": { "alias": "skipDelayDuration"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
}

/**
 * Wrapper around the row / column of items. Carries `data-orientation` so
 * the consumer can flip CSS layout. No semantic role — this is a layout
 * helper, not a `menubar` (the disclosure pattern doesn't use one).
 */
declare class ForNavigationMenuList {
    protected readonly ctx: NavigationMenuContext;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForNavigationMenuList, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForNavigationMenuList, "[forNavigationMenuList]", ["forNavigationMenuList"], {}, {}, never, never, true, never>;
}

/**
 * Wrapper around one trigger + its content. Owns the item's `value` (the
 * id used to coordinate which item is open) and its disabled state, then
 * exposes them downstream so the trigger and content can share a single
 * source of truth.
 */
declare class ForNavigationMenuItem implements ForNavigationMenuItemContext {
    #private;
    /**
     * Identifier matched against the menu's `value`, shared by this item's trigger and content.
     * Mandatory — an unbound item throws in dev mode.
     *
     * That seeding is what lets both pieces register **synchronously**: the
     * pairing then resolves during the first change-detection pass, including a
     * real server render, where `afterNextRender` never fires and a deferred
     * registration would leave the pre-hydration DOM without its
     * `aria-controls` / `aria-labelledby` linkage.
     */
    readonly value: _angular_core.InputSignal<string>;
    /**
     * Per-item disabled. Stands on its own — the root `[forNavigationMenu]`'s
     * `disabled` is merged with this value by the item's trigger
     * (`ForNavigationMenuTrigger.effectiveDisabled`), which is what reflects the
     * composed state and gates activation. This host's `data-disabled` reflects
     * the per-item value only.
     */
    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
    protected readonly state: _angular_core.Signal<"open" | "closed">;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForNavigationMenuItem, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForNavigationMenuItem, "[forNavigationMenuItem]", ["forNavigationMenuItem"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Disclosure trigger. Apply on `<button>`. Mouse hover / click open the paired
 * `[forNavigationMenuContent]`; arrow keys move focus across siblings;
 * ArrowDown (horizontal) / ArrowRight (vertical) open; Escape closes;
 * Enter / Space toggle.
 *
 * Per the APG disclosure-navigation pattern this does NOT open on plain
 * focus: Tabbing across the trigger row must not auto-expand panels, and a
 * programmatic return-focus (e.g. after Escape) must not synchronously
 * re-open the panel that just closed.
 *
 * Hover is a mouse affordance: the `pointerenter` / `pointerleave` path is
 * gated to hover-capable pointers, so a touch or pen tap drives the panel
 * through the native `click` instead of opening it mid-press.
 *
 * `aria-controls` is emitted only while the item is open, and only once the
 * paired `[forNavigationMenuContent]` has registered — an id that cannot be
 * resolved emits no attribute rather than an empty one, so the reference never
 * dangles (mirroring `[forAccordionTrigger]` and the carousel arrows).
 *
 * Disabling: {@link effectiveDisabled} merges the owning
 * `[forNavigationMenuItem]`'s `[disabled]` with the root
 * `[forNavigationMenu]`'s. It is reflected through a single channel,
 * `aria-disabled="true"` + `data-disabled`, and enforced by the click / hover /
 * keyboard guards; arrow navigation skips the trigger. The native `disabled`
 * attribute is NOT emitted: every trigger is its
 * own tab stop in this pattern, so a disabled trigger stays focusable and
 * announceable instead of vanishing from the trigger row — which a menu-level
 * `disabled` would otherwise do to the entire nav.
 */
declare class ForNavigationMenuTrigger {
    #private;
    protected readonly buttonType: Signal<string | null>;
    protected readonly menu: NavigationMenuContext;
    readonly id: Signal<string>;
    protected readonly value: Signal<string>;
    /**
     * Effective disabled state: the owning `[forNavigationMenuItem]`'s
     * `[disabled]` OR the root `[forNavigationMenu]`'s `disabled`. Everything
     * that gates on the trigger's disabled state reads this — the
     * `aria-disabled` / `data-disabled` reflection, the click / hover / keyboard
     * guards, and the arrow-navigation skip.
     */
    readonly effectiveDisabled: Signal<boolean>;
    protected readonly isOpen: Signal<boolean>;
    protected readonly contentId: Signal<string | null>;
    constructor();
    protected onClick(): void;
    protected onPointerEnter(event: PointerEvent): void;
    protected onPointerLeave(event: PointerEvent): void;
    protected onKeyDown(event: KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForNavigationMenuTrigger, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForNavigationMenuTrigger, "[forNavigationMenuTrigger]", ["forNavigationMenuTrigger"], {}, {}, never, never, true, never>;
}

/**
 * The disclosure panel for a navigation-menu item. Mounted via `@if`
 * (consumer drives it from `forNavigationMenu.value()` or
 * `forNavigationMenuItem`'s state) so animations work natively.
 *
 * Carries `aria-labelledby` pointing at the trigger and reflects
 * `data-state` for CSS hooks. A consumer-set **static** `aria-labelledby` on
 * the panel wins over that fallback and is preserved. No focus management is
 * imposed — content
 * is a regular landmark; Tab moves through links inside, then out to the
 * next focusable element after the wrapper.
 *
 * When a `[forNavigationMenuViewport]` is present in the menu, the host
 * element re-parents itself into the viewport on mount so all active
 * panels share a single animated surface (mega-menu pattern). The viewport
 * owns the ordering: each panel is inserted in its trigger's document
 * order, never simply appended in mount order. So during an overlapping
 * A→B transition — where the leaving A is still mounted (its
 * `animate.leave` keeps it around) while B enters — the viewport's child
 * order is deterministic and always matches trigger order: the panel whose
 * trigger comes first in the DOM is the first child, irrespective of which
 * panel mounted last. Cross-fade / slide carousels can therefore author
 * their stacking against trigger order (pair it with `data-motion`). The
 * directive does not undo the re-parent on destroy: the consumer's `@if`
 * is destroying the element anyway, and Angular's renderer removes nodes
 * by their actual current parent.
 *
 * `data-motion` is reflected (`from-start | from-end | to-start | to-end`)
 * for CSS keyframes that slide the entering and leaving panels together
 * during a transition.
 *
 * The host's `focusout` is delegated to the root, which acts on it only for a
 * leave that reports no destination (`relatedTarget === null`); every other
 * leave belongs to the dismissible layer's `'focus'` channel. This host is the
 * panel itself, so such a leave fired inside it always reaches the root — which
 * is what makes the rule independent of where a `[forNavigationMenuViewport]`
 * re-parented the panel: an externally-hosted panel's `focusout` never bubbles
 * to the `<nav>`.
 */
declare class ForNavigationMenuContent {
    #private;
    protected readonly menu: NavigationMenuContext;
    readonly id: Signal<string>;
    protected readonly value: Signal<string>;
    protected readonly labelledBy: Signal<string | null>;
    protected readonly motion: Signal<forty_cdk_navigation_menu.ForNavigationMenuMotion | null>;
    constructor();
    protected onPointerEnter(event: PointerEvent): void;
    protected onPointerLeave(event: PointerEvent): void;
    protected onEscape(event: KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForNavigationMenuContent, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForNavigationMenuContent, "[forNavigationMenuContent]", ["forNavigationMenuContent"], {}, {}, never, never, true, never>;
}

/**
 * Decorative marker for links inside a navigation-menu content. Reflects
 * `data-active` for CSS hooks (the consumer flips it based on the
 * router's current URL — the directive doesn't know about routing).
 *
 * Apply on `<a>`.
 */
declare class ForNavigationMenuLink {
    /** When true, this link points at the current page. Reflects `aria-current`. */
    readonly active: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Value forwarded to `aria-current` when `active` is true. Defaults to
     * `'page'` (the most common case for top-level navigation).
     */
    readonly ariaCurrent: _angular_core.InputSignal<"page" | "step" | "location" | "date" | "time" | "true">;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForNavigationMenuLink, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForNavigationMenuLink, "[forNavigationMenuLink]", ["forNavigationMenuLink"], { "active": { "alias": "active"; "required": false; "isSignal": true; }; "ariaCurrent": { "alias": "ariaCurrent"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Optional visual indicator (underline, pill) that follows the active
 * trigger. Computes geometry from the trigger's position relative to
 * `[forNavigationMenuList]` and exposes it via CSS custom properties:
 *
 * - `--for-navigation-menu-indicator-x` — horizontal offset (px)
 * - `--for-navigation-menu-indicator-y` — vertical offset (px)
 * - `--for-navigation-menu-indicator-width` — trigger width (px)
 * - `--for-navigation-menu-indicator-height` — trigger height (px)
 *
 * Drive `transform` / `width` / `height` from these in CSS. The directive
 * is decorative — set `aria-hidden="true"` on the host element if
 * needed.
 *
 * Geometry is re-measured reactively, not on every render: a `ResizeObserver`
 * (browser-only) watches the active trigger and the surrounding list and bumps
 * a measure-tick signal, and the offset / size are recomputed only when the
 * active trigger changes or one of those boxes resizes. `afterNextRender`
 * covers the initial measure once the host is in the DOM.
 */
declare class ForNavigationMenuIndicator {
    #private;
    protected readonly menu: NavigationMenuContext;
    protected readonly x: _angular_core.Signal<number>;
    protected readonly y: _angular_core.Signal<number>;
    protected readonly width: _angular_core.Signal<number>;
    protected readonly height: _angular_core.Signal<number>;
    protected readonly state: _angular_core.Signal<"visible" | "hidden">;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForNavigationMenuIndicator, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForNavigationMenuIndicator, "[forNavigationMenuIndicator]", ["forNavigationMenuIndicator"], {}, {}, never, never, true, never>;
}

/**
 * Optional shared surface for mega-menu style navigation. When present,
 * `[forNavigationMenuContent]` re-parents itself into this host on mount,
 * so all active content panels live inside a single visual container that
 * can animate width/height between trigger groups.
 *
 * The viewport exposes the active content's natural size as CSS custom
 * properties:
 *
 * - `--for-navigation-menu-viewport-width` (px)
 * - `--for-navigation-menu-viewport-height` (px)
 *
 * Drive `width` / `height` from these in CSS to get fluid resize between
 * panels. The directive is a real interactive surface (it hosts the
 * focusable content), so `aria-hidden="false"` is reflected explicitly to
 * counteract any wrapper that defaults to hidden.
 *
 * Two panels can briefly co-exist inside the viewport during a transition, since a leaving panel
 * stays mounted for as long as the consumer's `@if` keeps it, so a cross-fade or slide is possible.
 * Mount lifecycle stays with the consumer's template; this directive only re-parents and measures.
 *
 * Panels are inserted in their triggers' document order rather than in mount order, so during an
 * overlapping transition the panel whose trigger comes first is always the viewport's first child.
 * That gives carousels a deterministic axis to author against — pair it with the `data-motion` hook
 * on the content.
 *
 * Measurement follows the active panel only, so a panel kept mounted by `animate.leave` no longer
 * drives the viewport box, and the exposed variables reflect the entering panel as soon as it
 * becomes active.
 *
 * **Avoid a measurement feedback loop.** The variables are measured from the active content panel,
 * but the `ResizeObserver` also watches the host so a surrounding column resize is picked up. Do
 * not drive the host's own measured dimension from these variables while the host's box constrains
 * the panel's — a measure tick's CSS output would feed back into the next observation. Apply them
 * on a wrapper, or transition them on the host without coupling them to the measured child's size.
 *
 * @example
 * ```html
 * <nav forNavigationMenu [(value)]="open">
 *   <ul forNavigationMenuList>…</ul>
 *   <div forNavigationMenuViewport></div>
 * </nav>
 * ```
 */
declare class ForNavigationMenuViewport {
    #private;
    protected readonly menu: NavigationMenuContext;
    readonly host: HTMLElement;
    protected readonly width: _angular_core.Signal<number>;
    protected readonly height: _angular_core.Signal<number>;
    protected readonly state: _angular_core.Signal<"open" | "closed">;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForNavigationMenuViewport, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForNavigationMenuViewport, "[forNavigationMenuViewport]", ["forNavigationMenuViewport"], {}, {}, never, never, true, never>;
}

/**
 * Defaults inherited by descendant navigation menus in the surrounding
 * injector scope. Configure with `provideForNavigationMenuDefaults` either
 * at the application root or in any component's `providers` array; partial
 * overrides merge with the parent scope.
 */
interface ForNavigationMenuDefaults {
    /** ms before a hover opens an item. */
    openDelay: number;
    /** ms before an item closes after hover leaves. */
    closeDelay: number;
    /**
     * ms after a peer item closed during which the next open is instant.
     * Keeps fluid hover-across-triggers feeling responsive.
     */
    skipDelayDuration: number;
}
/** Token holding the resolved navigation-menu defaults for the current scope. */
declare const FOR_NAVIGATION_MENU_DEFAULTS: _angular_core.InjectionToken<ForNavigationMenuDefaults>;
/**
 * Configures forty-cdk navigation-menu defaults for this injector scope.
 * Partial overrides inherit unspecified keys from the parent scope (or
 * library defaults at the root).
 */
declare function provideForNavigationMenuDefaults(defaults?: Partial<ForNavigationMenuDefaults>): Provider[];

export { FOR_NAVIGATION_MENU_CONTEXT, FOR_NAVIGATION_MENU_DEFAULTS, FOR_NAVIGATION_MENU_ITEM_CONTEXT, ForNavigationMenu, ForNavigationMenuContent, ForNavigationMenuIndicator, ForNavigationMenuItem, ForNavigationMenuLink, ForNavigationMenuList, ForNavigationMenuTrigger, ForNavigationMenuViewport, provideForNavigationMenuDefaults };
export type { ForNavigationMenuContext, ForNavigationMenuDefaults, ForNavigationMenuItemContext, ForNavigationMenuMotion, NavigationMenuScheduleReason };