ng-hub-ui-nav 21.1.0

package/types/ng-hub-ui-nav.d.ts

@@ -0,0 +1,1280 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, TemplateRef, AfterViewInit, OnDestroy, OnInit } from '@angular/core';
+import * as ng_hub_ui_nav from 'ng-hub-ui-nav';
+
+/**
+ * Configuration for the `hub-nav` component.
+ * All properties are optional — defaults are applied via `HubNavConfigService`.
+ */
+interface HubNavConfig {
+    /**
+     * Orientation of the navigation menu.
+     * - `horizontal`: Top navigation bar.
+     * - `vertical`: Side navigation bar.
+     * @default 'horizontal'
+     */
+    orientation: HubNavOrientation;
+    /**
+     * Expansion mode for child items in vertical orientation.
+     * - `accordion`: Children expand/collapse inline with animation.
+     * - `flyout`: Children appear as a positioned side panel.
+     * @default 'accordion'
+     */
+    verticalExpandMode: HubNavVerticalExpandMode;
+    /**
+     * Trigger mechanism for opening dropdowns.
+     * - `hover`: Open on mouse hover.
+     * - `click`: Open on click.
+     * - `both`: Open on hover or click.
+     * @default 'click'
+     */
+    dropdownTrigger: HubNavDropdownTrigger;
+    /**
+     * CSS positioning strategy for the nav container.
+     * Sticky positioning is only activated for vertical, non-collapsed navs.
+     * @default 'static'
+     */
+    position: HubNavPosition;
+    /**
+     * Top offset used when sticky positioning is enabled.
+     * Accepts any valid CSS length value.
+     * @default '0px'
+     */
+    stickyTop: string;
+    /**
+     * Display mode when the menu collapses on smaller viewports.
+     * - `offcanvas`: Slide-in drawer panel.
+     * - `dropdown`: Panel drops below the toggler.
+     * - `fullscreen`: Full-screen overlay.
+     * @default 'offcanvas'
+     */
+    collapseMode: HubNavCollapseMode;
+    /**
+     * Viewport width in pixels below which the menu collapses.
+     * Set to `0` to disable responsive collapsing.
+     * @default 992
+     */
+    collapseBreakpoint: number;
+    /**
+     * Position from which the offcanvas panel slides in.
+     * Only applicable when `collapseMode` is `'offcanvas'`.
+     * @default 'start'
+     */
+    offcanvasPosition: HubNavOffcanvasPosition;
+    /**
+     * Accessible label for the `<nav>` element.
+     * @default 'Navigation'
+     */
+    ariaLabel: string;
+    /**
+     * Maximum number of simultaneously visible panels in panel expand mode.
+     * When exceeded, the last panel uses drill-down (replaces its content with back navigation).
+     * Only applies when `verticalExpandMode` is `'panel'` or individual items have `expandMode: 'panel'`.
+     * @default 3
+     */
+    panelMaxVisible: number;
+    /**
+     * Physical side where the sidebar is placed.
+     * - `left`: Sidebar on the left, panels extend to the right.
+     * - `right`: Sidebar on the right, panels extend to the left.
+     * @default 'left'
+     */
+    sidebarSide: HubNavSidebarSide;
+    /**
+     * Width of each panel in panel expand mode.
+     * Accepts any valid CSS width value.
+     * @default '16rem'
+     */
+    panelWidth: string;
+}
+/** Orientation of the navigation layout. */
+type HubNavOrientation = 'horizontal' | 'vertical';
+/** Expansion mode for vertical child items. */
+type HubNavVerticalExpandMode = 'accordion' | 'flyout' | 'panel';
+/** Physical placement side of the sidebar navigation. */
+type HubNavSidebarSide = 'left' | 'right';
+/** Trigger mechanism for dropdown menus. */
+type HubNavDropdownTrigger = 'hover' | 'click' | 'both';
+/** CSS positioning strategy. */
+type HubNavPosition = 'static' | 'sticky' | 'fixed';
+/** Collapse display mode for responsive viewports. */
+type HubNavCollapseMode = 'offcanvas' | 'dropdown' | 'fullscreen';
+/** Offcanvas slide-in direction. */
+type HubNavOffcanvasPosition = 'start' | 'end' | 'top' | 'bottom';
+
+/**
+ * Represents a single navigation item in the menu hierarchy.
+ * Supports unlimited nesting through the `children` property.
+ */
+interface HubNavItem {
+    /** Unique identifier for the item. */
+    id: string;
+    /** Visible text label. */
+    label: string;
+    /**
+     * Type of navigation item.
+     * - `link`: Navigable item with routerLink.
+     * - `dropdown`: Parent item that opens a submenu with children.
+     * - `header`: Non-clickable section header text.
+     * - `separator`: Visual divider between groups.
+     * - `custom`: Custom content rendered via template directive.
+     */
+    type: HubNavItemType;
+    /** Icon CSS class or identifier (e.g., `'bi bi-house'`). */
+    icon?: string;
+    /** Route path for `routerLink`. Can be a string or an array of segments. */
+    route?: string | string[];
+    /** Query parameters for `routerLink`. */
+    queryParams?: Record<string, string>;
+    /** URL fragment for `routerLink`. */
+    fragment?: string;
+    /** Options for `routerLinkActive` matching. */
+    routerLinkActiveOptions?: {
+        exact: boolean;
+    };
+    /** Child items for dropdown/nested menus. Supports unlimited depth. */
+    children?: HubNavItem[];
+    /** Badge text displayed alongside the label (e.g., notification count). */
+    badge?: string;
+    /** CSS class applied to the badge element. */
+    badgeClass?: string;
+    /** Whether the item is disabled (visually muted, non-interactive). */
+    disabled?: boolean;
+    /** Additional CSS class applied to the item element. */
+    cssClass?: string;
+    /** Arbitrary consumer data attached to the item. */
+    data?: unknown;
+    /**
+     * Per-item override for how children are expanded.
+     * If set, overrides the global `verticalExpandMode` for this specific item.
+     * - `accordion`: Children expand inline.
+     * - `flyout`: Children appear as a positioned dropdown.
+     * - `panel`: Children open in a new stacked side panel.
+     */
+    expandMode?: HubNavVerticalExpandMode;
+}
+/** Allowed types for navigation items. */
+type HubNavItemType = 'link' | 'dropdown' | 'header' | 'separator' | 'custom';
+
+/**
+ * Template context provided to the `hubNavItemTemplate` directive.
+ * Allows consumers to customize how individual nav items are rendered.
+ */
+interface HubNavItemTemplateContext {
+    /** The navigation item being rendered. */
+    $implicit: HubNavItem;
+    /** Whether the item (or one of its descendants) is currently active. */
+    active: boolean;
+    /** Whether the item's dropdown is currently expanded (only for `type: 'dropdown'`). */
+    expanded: boolean;
+    /** Nesting depth level (0 = root level). */
+    depth: number;
+}
+/**
+ * Template context provided to the `hubNavStart` directive.
+ */
+interface HubNavStartTemplateContext {
+    /** Whether the navigation menu is currently collapsed (mobile viewport). */
+    collapsed: boolean;
+}
+/**
+ * Template context provided to the `hubNavEnd` directive.
+ */
+interface HubNavEndTemplateContext {
+    /** Whether the navigation menu is currently collapsed (mobile viewport). */
+    collapsed: boolean;
+}
+
+/**
+ * Event emitted when a navigation item is clicked.
+ */
+interface HubNavItemClickEvent {
+    /** The item that was clicked. */
+    item: HubNavItem;
+    /** The original DOM event. */
+    originalEvent: Event;
+}
+/**
+ * Event emitted when a dropdown opens or closes.
+ */
+interface HubNavDropdownEvent {
+    /** The dropdown parent item. */
+    item: HubNavItem;
+    /** Whether the dropdown is now open. */
+    open: boolean;
+}
+/** Action type for panel events. */
+type HubNavPanelAction = 'open' | 'close' | 'drill-down' | 'drill-back';
+/**
+ * Event emitted when a panel opens, closes, or performs drill-down navigation.
+ */
+interface HubNavPanelEvent {
+    /** The parent item whose children are displayed in the panel. */
+    item: HubNavItem;
+    /** Zero-based index of the panel in the stack. */
+    panelIndex: number;
+    /** The action that triggered this event. */
+    action: HubNavPanelAction;
+}
+
+/**
+ * Represents a single entry in the drill-down history stack of a panel.
+ */
+interface HubNavPanelHistoryEntry {
+    /** The items that were displayed before the drill-down. */
+    items: HubNavItem[];
+    /** The parent item of the previous level (used when navigating back). */
+    parentItem: HubNavItem;
+}
+/**
+ * Represents the state of a single panel in the stacked panel navigation.
+ */
+interface HubNavPanelState {
+    /** Unique identifier for this panel instance. */
+    id: string;
+    /** The parent item that triggered opening this panel. */
+    parentItem: HubNavItem;
+    /** The items currently displayed in this panel. */
+    items: HubNavItem[];
+    /** History stack for drill-down navigation within this panel. */
+    history: HubNavPanelHistoryEntry[];
+    /** Whether this panel is currently in drill-down mode (has history entries). */
+    isDrillDown: boolean;
+}
+
+/**
+ * Injection token for providing global nav configuration at application startup.
+ *
+ * @example
+ * ```typescript
+ * import { HUB_NAV_CONFIG } from 'ng-hub-ui-nav';
+ *
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     {
+ *       provide: HUB_NAV_CONFIG,
+ *       useValue: {
+ *         orientation: 'vertical',
+ *         dropdownTrigger: 'hover',
+ *         collapseBreakpoint: 768
+ *       }
+ *     }
+ *   ]
+ * };
+ * ```
+ */
+declare const HUB_NAV_CONFIG: InjectionToken<Partial<HubNavConfig>>;
+/**
+ * Global configuration service for `hub-nav` components.
+ * Provides centralized configuration management with signal-based reactivity.
+ *
+ * @example
+ * ```typescript
+ * const configService = inject(HubNavConfigService);
+ * configService.updateConfig({ orientation: 'vertical' });
+ * const config = configService.getConfig();
+ * ```
+ */
+declare class HubNavConfigService {
+    /** Signal containing the current global configuration. */
+    private config;
+    /**
+     * Returns the current configuration as a readonly signal.
+     *
+     * @returns Readonly signal with the current `HubNavConfig`.
+     */
+    getConfig(): _angular_core.Signal<HubNavConfig>;
+    /**
+     * Returns the default configuration values.
+     *
+     * @returns A copy of the default `HubNavConfig`.
+     */
+    getDefaults(): HubNavConfig;
+    /**
+     * Merges the given partial configuration into the current config.
+     *
+     * @param partial - Partial configuration to merge.
+     */
+    updateConfig(partial: Partial<HubNavConfig>): void;
+    /**
+     * Resets the configuration to factory defaults.
+     */
+    resetToDefaults(): void;
+    /**
+     * Resolves a complete config by merging defaults with the given partial overrides.
+     * Used internally by `hub-nav` to merge component-level inputs with global defaults.
+     *
+     * @param overrides - Partial configuration from the component input.
+     * @returns A complete `HubNavConfig`.
+     */
+    resolve(overrides: Partial<HubNavConfig>): HubNavConfig;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubNavConfigService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<HubNavConfigService>;
+}
+
+/**
+ * Internal state management service for a single `hub-nav` instance.
+ * Scoped per component — provided at the component level, not root.
+ *
+ * Manages:
+ * - Resolved configuration.
+ * - Open dropdown tracking.
+ * - Mobile menu state.
+ * - Active route propagation.
+ * - Panel stack for drill-down navigation.
+ */
+declare class HubNavStateService {
+    /** Currently resolved configuration. */
+    private _config;
+    /** Set of dropdown item IDs that are currently open. */
+    private _openDropdowns;
+    /** Whether the mobile panel is open. */
+    private _mobileOpen;
+    /** Whether the viewport is below the collapse breakpoint. */
+    private _collapsed;
+    /** Stack of open panels for panel expand mode. */
+    private _panelStack;
+    /** Auto-incrementing counter for unique panel IDs. */
+    private _panelIdCounter;
+    /** Readonly config signal. */
+    readonly config: _angular_core.Signal<HubNavConfig>;
+    /** Readonly mobile-open signal. */
+    readonly mobileOpen: _angular_core.Signal<boolean>;
+    /** Readonly collapsed signal. */
+    readonly collapsed: _angular_core.Signal<boolean>;
+    /** Readonly panel stack signal. */
+    readonly panelStack: _angular_core.Signal<HubNavPanelState[]>;
+    /** Number of currently open panels. */
+    readonly panelCount: _angular_core.Signal<number>;
+    /** Computed orientation shortcut. */
+    readonly orientation: _angular_core.Signal<ng_hub_ui_nav.HubNavOrientation>;
+    /** Computed vertical expand mode shortcut. */
+    readonly verticalExpandMode: _angular_core.Signal<HubNavVerticalExpandMode>;
+    /** Computed dropdown trigger shortcut. */
+    readonly dropdownTrigger: _angular_core.Signal<ng_hub_ui_nav.HubNavDropdownTrigger>;
+    /**
+     * Updates the resolved configuration.
+     *
+     * @param config - Full resolved configuration.
+     */
+    setConfig(config: HubNavConfig): void;
+    /**
+     * Normalizes the panel stack after config changes.
+     *
+     * This is required when `panelMaxVisible` changes after panels were already
+     * opened (for example during initial input binding in the host app shell).
+     * Without this reconciliation, the UI can temporarily render more panels
+     * than allowed or keep a last panel without header while its parent panel
+     * is no longer visible.
+     *
+     * @param config - The latest resolved configuration.
+     */
+    private reconcilePanelStackWithConfig;
+    /**
+     * Checks whether a dropdown with the given item ID is open.
+     *
+     * @param id - Item ID to check.
+     * @returns `true` if the dropdown is open.
+     */
+    isDropdownOpen(id: string): boolean;
+    /**
+     * Opens a dropdown by item ID.
+     * In accordion mode, closes sibling dropdowns at the same level.
+     *
+     * @param id - Item ID to open.
+     * @param siblings - Optional array of sibling item IDs to close when opening this one.
+     */
+    openDropdown(id: string, siblings?: string[]): void;
+    /**
+     * Closes a dropdown by item ID.
+     *
+     * @param id - Item ID to close.
+     */
+    closeDropdown(id: string): void;
+    /**
+     * Toggles a dropdown open/closed by item ID.
+     *
+     * @param id - Item ID to toggle.
+     * @returns `true` if the dropdown is now open.
+     */
+    toggleDropdown(id: string): boolean;
+    /** Closes all open dropdowns. */
+    closeAllDropdowns(): void;
+    /**
+     * Synchronizes the open dropdown set with the current active route.
+     * Only ancestor items in the active trail remain open.
+     *
+     * @param items - Root navigation items to inspect.
+     * @param activeRoute - Current router URL including optional fragment.
+     */
+    syncDropdownsWithRoute(items: HubNavItem[], activeRoute: string): void;
+    /**
+     * Sets the mobile panel open state.
+     *
+     * @param open - Whether the mobile panel should be open.
+     */
+    setMobileOpen(open: boolean): void;
+    /** Toggles the mobile panel. */
+    toggleMobile(): void;
+    /**
+     * Sets the collapsed state (below breakpoint).
+     *
+     * @param collapsed - Whether the viewport is below the collapse breakpoint.
+     */
+    setCollapsed(collapsed: boolean): void;
+    /**
+     * Opens a new panel for the given parent item's children.
+     * If the panel count has reached `panelMaxVisible`, drills down within the last panel instead.
+     *
+     * @param parentItem - The item whose children should be displayed in the panel.
+     * @param rootItems - The root-level navigation items (to determine if parentItem is at root level).
+     */
+    openPanel(parentItem: HubNavItem, rootItems?: HubNavItem[]): void;
+    /**
+     * Finds the depth (index) where a panel for the given item should be placed.
+     * Returns the index of the first panel whose items contain parentItem,
+     * or -1 if parentItem is not found in any panel.
+     *
+     * @param parentItem - The item to search for.
+     * @param stack - The current panel stack.
+     * @returns The panel index, or -1 if not found.
+     */
+    private findPanelDepth;
+    /**
+     * Finds the ordered list of dropdown ancestor IDs for the active route.
+     *
+     * @param items - Items to search recursively.
+     * @param activeRoute - Current router URL.
+     * @param trail - Accumulated ancestor trail.
+     * @returns Ancestor IDs that must remain expanded.
+     */
+    private findActiveDropdownTrail;
+    /**
+     * Closes a panel by its ID and all panels opened after it.
+     *
+     * @param panelId - ID of the panel to close.
+     */
+    closePanel(panelId: string): void;
+    /**
+     * Closes all panels from the given index onward.
+     *
+     * @param index - Zero-based index from which to start closing.
+     */
+    closePanelsFromIndex(index: number): void;
+    /** Closes all open panels. */
+    closeAllPanels(): void;
+    /**
+     * Performs a drill-down within an existing panel: pushes current items to history
+     * and replaces them with the new item's children.
+     *
+     * @param panelId - ID of the panel to drill down in.
+     * @param parentItem - The item whose children will replace the panel content.
+     * @param items - The new items to display.
+     */
+    drillDownInPanel(panelId: string, parentItem: HubNavItem, items: HubNavItem[]): void;
+    /**
+     * Navigates back one level in a panel's drill-down history.
+     * If there is no history, the panel is closed.
+     *
+     * @param panelId - ID of the panel to navigate back in.
+     */
+    navigateBackInPanel(panelId: string): void;
+    /**
+     * Retrieves a panel by its ID.
+     *
+     * @param panelId - ID of the panel to find.
+     * @returns The panel state, or `undefined` if not found.
+     */
+    getPanelById(panelId: string): HubNavPanelState | undefined;
+    /**
+     * Checks whether there is an open panel whose parent item matches the given ID.
+     *
+     * @param itemId - Parent item ID to match against the panel stack.
+     * @returns `true` when a panel for the given item is currently open.
+     */
+    isPanelOpenForItem(itemId: string): boolean;
+    /**
+     * Resolves the effective expand mode for an item, considering:
+     * 1. Per-item `expandMode` override.
+     * 2. Global `verticalExpandMode` from config.
+     * 3. Fallback to `'accordion'` when collapsed (mobile).
+     *
+     * @param item - The item to resolve the expand mode for.
+     * @returns The effective expand mode.
+     */
+    getEffectiveExpandMode(item: HubNavItem): HubNavVerticalExpandMode;
+    /**
+     * Recursively checks whether the given item or any of its descendants
+     * match the provided active route.
+     *
+     * @param item - Item to check.
+     * @param activeRoute - Currently active route path.
+     * @returns `true` if the item or a descendant is active.
+     */
+    isItemOrDescendantActive(item: HubNavItem, activeRoute: string): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubNavStateService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<HubNavStateService>;
+}
+
+/**
+ * Structural directive that projects content into the navigation start slot.
+ *
+ * Slot behavior:
+ * - Horizontal nav: appears at the visual start (left in LTR, right in RTL).
+ * - Vertical nav: appears at the top of the primary column.
+ *
+ * The template receives a {@link HubNavStartTemplateContext}.
+ */
+declare class HubNavStartDirective {
+    /** Reference to the projected template. */
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubNavStartDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HubNavStartDirective, "[hubNavStart]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Structural directive that projects content into the navigation end slot.
+ *
+ * Slot behavior:
+ * - Horizontal nav: appears at the visual end (right in LTR, left in RTL).
+ * - Vertical nav: appears at the bottom of the primary column.
+ *
+ * The template receives a {@link HubNavEndTemplateContext}.
+ */
+declare class HubNavEndDirective {
+    /** Reference to the projected template. */
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubNavEndDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HubNavEndDirective, "[hubNavEnd]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Structural directive that provides a custom template for rendering individual nav items.
+ * When present, each nav item is rendered using this template instead of the default markup.
+ *
+ * The template receives a {@link HubNavItemTemplateContext} with `$implicit` (the item),
+ * `active`, `expanded`, and `depth`.
+ *
+ * @example
+ * ```html
+ * <hub-nav [items]="menuItems">
+ *   <ng-template hubNavItemTemplate let-item let-active="active" let-depth="depth">
+ *     <div class="custom-item" [class.active]="active">
+ *       <i [class]="item.icon"></i>
+ *       {{ item.label }}
+ *     </div>
+ *   </ng-template>
+ * </hub-nav>
+ * ```
+ */
+declare class HubNavItemTemplateDirective {
+    /** Reference to the template provided by the consumer. */
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubNavItemTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HubNavItemTemplateDirective, "[hubNavItemTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Scroll spy container directive that tracks the currently visible section and
+ * emits section changes using `IntersectionObserver`.
+ */
+declare class HubNavScrollSpyDirective implements AfterViewInit, OnDestroy {
+    /** Enables or disables section tracking. */
+    readonly enabled: _angular_core.InputSignal<boolean>;
+    /** Top offset in pixels to compensate sticky headers. */
+    readonly offset: _angular_core.InputSignal<number>;
+    /** CSS selector used to locate section elements inside the host container. */
+    readonly sectionSelector: _angular_core.InputSignal<string>;
+    /** Emits the active section id whenever it changes. */
+    readonly activeSectionChange: _angular_core.OutputEmitterRef<string>;
+    private readonly el;
+    private readonly zone;
+    private observer;
+    private activeId;
+    private initialized;
+    /** Current active section id (readonly signal). */
+    readonly activeSectionId: _angular_core.Signal<string | null>;
+    private readonly configEffect;
+    /** @inheritDoc */
+    ngAfterViewInit(): void;
+    /** @inheritDoc */
+    ngOnDestroy(): void;
+    /**
+     * Scrolls to a tracked section by id.
+     *
+     * @param sectionId - Target section id.
+     * @param behavior - Native scroll behavior.
+     * @returns `true` when the target exists and scroll was requested.
+     */
+    scrollTo(sectionId: string, behavior?: ScrollBehavior): boolean;
+    private scheduleInit;
+    private initializeObserver;
+    private destroyObserver;
+    private getSectionElements;
+    private getSectionId;
+    private handleObserverEntries;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubNavScrollSpyDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HubNavScrollSpyDirective, "[hubNavScrollSpy]", ["hubNavScrollSpy"], { "enabled": { "alias": "hubNavScrollSpy"; "required": false; "isSignal": true; }; "offset": { "alias": "offset"; "required": false; "isSignal": true; }; "sectionSelector": { "alias": "sectionSelector"; "required": false; "isSignal": true; }; }, { "activeSectionChange": "activeSectionChange"; }, never, never, true, never>;
+}
+
+/**
+ * Marks an element as a trackable section for `HubNavScrollSpyDirective`.
+ *
+ * If no explicit section id is provided, the directive falls back to the host
+ * element `id` attribute.
+ */
+declare class HubNavScrollSpySectionDirective {
+    /** Optional section id. When omitted, host `id` is used. */
+    readonly sectionId: _angular_core.InputSignal<string | null>;
+    private readonly el;
+    /** Effective section id exposed to the container directive. */
+    readonly resolvedSectionId: _angular_core.Signal<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubNavScrollSpySectionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HubNavScrollSpySectionDirective, "[hubNavScrollSpySection]", never, { "sectionId": { "alias": "hubNavScrollSpySection"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Root navigation component. Renders a horizontal or vertical navigation bar
+ * with support for nested dropdowns, responsive collapsing, brand slot, panel
+ * drill-down navigation, and custom item templates.
+ *
+ * @example
+ * ```html
+ * <hub-nav [items]="menuItems" [config]="{ orientation: 'horizontal' }" />
+ * ```
+ */
+declare class HubNavComponent implements OnInit, OnDestroy {
+    /**
+     * Last route path (without query/fragment) used to synchronize panel state.
+     * Prevents unnecessary panel rebuilds on fragment-only navigations, e.g.
+     * scroll-spy updates in documentation pages.
+     */
+    private _lastSyncedPath;
+    /** Navigation items to render. */
+    readonly items: _angular_core.InputSignal<HubNavItem[]>;
+    /** Partial configuration overrides (merged with global defaults). */
+    readonly config: _angular_core.InputSignal<Partial<HubNavConfig>>;
+    /** Additional CSS class for the nav container. */
+    readonly navClass: _angular_core.InputSignal<string>;
+    /** Optional custom template for rendering nav items (via input binding). */
+    readonly itemTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    /**
+     * When `true`, the component automatically opens the panels matching the
+     * active router URL on initialization and on every subsequent navigation.
+     * Useful for sidebar navigations where the URL should drive the open state.
+     */
+    readonly autoOpenFromRoute: _angular_core.InputSignal<boolean>;
+    /** Start slot template projected via `hubNavStart` directive. */
+    private readonly startDirective;
+    /** End slot template projected via `hubNavEnd` directive. */
+    private readonly endDirective;
+    /** Item template projected via `hubNavItemTemplate` directive. */
+    private readonly itemTemplateDirective;
+    /** Resolved start slot template (from directive content projection). */
+    readonly startTemplate: _angular_core.Signal<TemplateRef<any> | null>;
+    /** Resolved end slot template (from directive content projection). */
+    readonly endTemplate: _angular_core.Signal<TemplateRef<any> | null>;
+    /** Resolved item template: directive takes priority over input. */
+    readonly resolvedItemTemplate: _angular_core.Signal<TemplateRef<any> | null>;
+    /** Start slot context. */
+    readonly startContext: _angular_core.Signal<{
+        collapsed: boolean;
+    }>;
+    /** End slot context. */
+    readonly endContext: _angular_core.Signal<{
+        collapsed: boolean;
+    }>;
+    /** Emitted when a link item is clicked. */
+    readonly itemClick: _angular_core.OutputEmitterRef<HubNavItem>;
+    /** Emitted when a dropdown opens. */
+    readonly dropdownOpen: _angular_core.OutputEmitterRef<HubNavItem>;
+    /** Emitted when a dropdown closes. */
+    readonly dropdownClose: _angular_core.OutputEmitterRef<HubNavItem>;
+    /** Emitted when the mobile panel toggles. */
+    readonly mobileToggle: _angular_core.OutputEmitterRef<boolean>;
+    /** Emitted when a panel is opened, drilled-down, or navigated back. */
+    readonly panelChange: _angular_core.OutputEmitterRef<HubNavPanelEvent>;
+    /** Global config service. */
+    private readonly configService;
+    /** Scoped state service (provided per component). */
+    readonly state: HubNavStateService;
+    /** Host element reference for click-outside detection. */
+    private readonly elementRef;
+    /** NgZone for running outside-click handler inside Angular. */
+    private readonly zone;
+    /** Angular router for URL-based panel initialization. */
+    private readonly router;
+    /** Whether component lifecycle initialization has completed. */
+    private initialized;
+    /** Last applied config signature used to prevent reactive no-op loops. */
+    private lastAppliedConfigSignature;
+    /** Last breakpoint-related signature used to avoid redundant listener rebinds. */
+    private lastBreakpointSignature;
+    /** Subscription for router NavigationEnd events. */
+    private routerSub?;
+    /** Media query list for responsive breakpoint detection. */
+    private mediaQuery;
+    /** Bound handler for media query changes. */
+    private mediaQueryHandler;
+    /** Bound handler for window resize fallback. */
+    private resizeHandler;
+    /** Bound handler for document click events (click-outside). */
+    private documentClickHandler;
+    /** Resolved config = global defaults + component overrides. */
+    readonly resolvedConfig: _angular_core.Signal<HubNavConfig>;
+    /** Shortcut to resolved orientation. */
+    readonly resolvedOrientation: _angular_core.Signal<ng_hub_ui_nav.HubNavOrientation>;
+    /** Whether panels are currently active (panel stack is non-empty). */
+    readonly hasPanels: _angular_core.Signal<boolean>;
+    /** The sidebar side from resolved config. */
+    readonly sidebarSide: _angular_core.Signal<ng_hub_ui_nav.HubNavSidebarSide>;
+    /** The panel width from resolved config. */
+    readonly panelWidth: _angular_core.Signal<string>;
+    /** Sync config to state service whenever it changes. */
+    private configEffect;
+    /** ARIA label for the nav element. */
+    readonly ariaLabel: _angular_core.Signal<string>;
+    /** Whether the viewport is below the collapse breakpoint. */
+    readonly isCollapsed: _angular_core.Signal<boolean>;
+    /** Whether the mobile panel is open. */
+    readonly isMobileOpen: _angular_core.Signal<boolean>;
+    /** Collapse mode from resolved config. */
+    readonly collapseMode: _angular_core.Signal<ng_hub_ui_nav.HubNavCollapseMode>;
+    /** Offcanvas position from resolved config. */
+    readonly offcanvasPosition: _angular_core.Signal<ng_hub_ui_nav.HubNavOffcanvasPosition>;
+    /**
+     * Whether sticky positioning should be activated for the current layout.
+     * Sticky mode is restricted to vertical navigation and also applies while
+     * the nav is collapsed on mobile so the toggler row stays pinned.
+     */
+    readonly isStickyActive: _angular_core.Signal<boolean>;
+    /** @inheritDoc */
+    ngOnInit(): void;
+    /** @inheritDoc */
+    ngOnDestroy(): void;
+    /**
+     * Handles item click events bubbled up from the item list.
+     *
+     * @param payload - The clicked item and original DOM event.
+     */
+    onItemClick(payload: {
+        item: HubNavItem;
+        event: Event;
+    }): void;
+    /**
+     * Toggles the mobile panel and emits the state change.
+     */
+    onMobileToggle(): void;
+    /**
+     * Closes the mobile panel.
+     */
+    onMobilePanelClose(): void;
+    /**
+     * Handles dropdown toggle events bubbled up from the item list.
+     * The toggle has already been performed in the item-list; this just
+     * emits the appropriate output event.
+     *
+     * @param item - The dropdown item that was toggled.
+     */
+    onDropdownToggle(item: HubNavItem): void;
+    /**
+     * Opens a new panel for the given item's children, or drills down if max panels reached.
+     * Focuses the first item in the newly opened/drilled panel.
+     *
+     * @param item - The item whose children should be displayed in a panel.
+     */
+    onPanelOpen(item: HubNavItem): void;
+    /**
+     * Closes a panel and all panels opened after it.
+     * Returns focus to the previous panel or the main nav trigger.
+     *
+     * @param panelId - ID of the panel to close.
+     */
+    onPanelClose(panelId: string): void;
+    /**
+     * Navigates back within a panel's drill-down history.
+     * Focuses the first item after navigating back.
+     *
+     * @param panelId - ID of the panel to navigate back in.
+     */
+    onPanelBack(panelId: string): void;
+    /**
+     * Focuses the first focusable item inside a panel at the given index.
+     *
+     * @param panelIndex - Zero-based index of the panel in the DOM.
+     */
+    private focusPanelFirstItem;
+    /**
+     * Returns focus to the appropriate element after a panel is closed.
+     * If a previous panel exists, focuses its trigger for the closed item.
+     * Otherwise, returns focus to the main nav item-list.
+     *
+     * @param closedIndex - The index of the panel that was closed.
+     * @param parentItemId - The ID of the parent item that triggered the closed panel.
+     */
+    private returnFocusAfterPanelClose;
+    /**
+     * Sets up a `matchMedia` listener for the configured collapse breakpoint.
+     */
+    private setupBreakpointListener;
+    /** Tears down the `matchMedia` listener. */
+    private teardownBreakpointListener;
+    /**
+     * Registers a document click listener that closes dropdowns on outside clicks.
+     * Panel drill-down mode panels are NOT closed by outside clicks.
+     */
+    private setupClickOutsideListener;
+    /** Removes the document click listener. */
+    private teardownClickOutsideListener;
+    /**
+     * Callback invoked when the viewport crosses the collapse breakpoint.
+     *
+     * @param belowBreakpoint - `true` if the viewport is now below the breakpoint.
+     */
+    private onBreakpointChange;
+    /**
+     * Recomputes the collapsed state from the current viewport width.
+     * This complements `matchMedia` events, which can become unreliable in
+     * some browser/devtools combinations when the viewport is resized or
+     * docked without emitting the expected media-query change sequence.
+     */
+    private refreshCollapsedState;
+    /**
+     * Parses the given URL and opens the panels that correspond to the active route.
+     *
+     * The algorithm:
+     * 1. Extract the path without fragment/query: `/calendar/examples` → `['calendar', 'examples']`
+     * 2. Find the root item whose id matches the first segment.
+     * 3. Open a panel for that root item (closes any existing panels first).
+     * 4. If a second segment exists and matches a child item that has its own
+     *    children (e.g. the "Examples" dropdown), open a second panel for it.
+     *
+     * @param url - The full URL including optional fragment, e.g. `/calendar/examples#cal-basic`.
+     */
+    private openPanelsFromRoute;
+    /**
+     * Checks whether the first panel in the current stack belongs to the same
+     * root route context.
+     *
+     * This remains true even when panel mode drill-down has replaced the first
+     * panel content (the original root items are still present in panel history).
+     *
+     * @param rootItem - Root nav item resolved from the current route.
+     * @param stack - Current panel stack snapshot.
+     * @returns `true` when the stack already belongs to the same root context.
+     */
+    private isRootContextVisible;
+    /**
+     * Compares two item collections by stable item IDs.
+     *
+     * @param source - First collection.
+     * @param target - Second collection.
+     * @returns `true` when both collections contain the same IDs in the same order.
+     */
+    private isSameItemCollection;
+    /**
+     * Restores the first panel to the root context when it is currently showing
+     * drill-down content for a child section (e.g. the "Examples" third level).
+     *
+     * @param rootItem - Root nav item resolved from the current route.
+     */
+    private ensureRootPanelContext;
+    /**
+     * Extracts the path part from a URL-like string, removing query and fragment.
+     *
+     * @param url - Router URL.
+     * @returns Normalized path for route-state comparisons.
+     */
+    private extractPath;
+    /**
+     * Builds a stable signature for the effective nav config so repeated
+     * reactivity passes with identical values do not trigger work.
+     *
+     * @param config - Effective nav config.
+     * @returns Stable string signature.
+     */
+    private buildConfigSignature;
+    /**
+     * Builds a stable signature for breakpoint listener inputs.
+     *
+     * @param config - Effective nav config.
+     * @returns Stable breakpoint signature.
+     */
+    private buildBreakpointSignature;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubNavComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HubNavComponent, "hub-nav", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "navClass": { "alias": "navClass"; "required": false; "isSignal": true; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; "isSignal": true; }; "autoOpenFromRoute": { "alias": "autoOpenFromRoute"; "required": false; "isSignal": true; }; }, { "itemClick": "itemClick"; "dropdownOpen": "dropdownOpen"; "dropdownClose": "dropdownClose"; "mobileToggle": "mobileToggle"; "panelChange": "panelChange"; }, ["startDirective", "endDirective", "itemTemplateDirective"], never, true, never>;
+}
+
+/**
+ * Renders a single navigation item (link, dropdown trigger, header, or custom content).
+ * Handles routing integration, active state, badges, icons, and disabled state.
+ *
+ * @internal Used internally by `HubNavItemListComponent`.
+ */
+declare class HubNavItemComponent {
+    /** The navigation item data to render. */
+    readonly item: _angular_core.InputSignal<HubNavItem>;
+    /** Nesting depth (0 = root). */
+    readonly depth: _angular_core.InputSignal<number>;
+    /** Whether this item is currently active (set by parent list). */
+    readonly isActive: _angular_core.InputSignal<boolean>;
+    /** Whether the dropdown is currently expanded (only for dropdown items). */
+    readonly isExpanded: _angular_core.InputSignal<boolean>;
+    /** Optional custom template for rendering the item content. */
+    readonly itemTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    /**
+     * Forces the item to behave as part of a mobile accordion list.
+     * This keeps indicators and layout aligned with the collapsed nav panel.
+     */
+    readonly forceAccordionMode: _angular_core.InputSignal<boolean>;
+    /** Emitted when the item is clicked. */
+    readonly clicked: _angular_core.OutputEmitterRef<{
+        item: HubNavItem;
+        event: Event;
+    }>;
+    /** Emitted when the dropdown toggle is activated. */
+    readonly toggleDropdown: _angular_core.OutputEmitterRef<HubNavItem>;
+    /** Reference to the nav state service. */
+    private readonly state;
+    /** Whether this item has child items. */
+    readonly hasChildren: _angular_core.Signal<boolean>;
+    /** Whether this item is a header type. */
+    readonly isHeader: _angular_core.Signal<boolean>;
+    /** Whether this item is a link type. */
+    readonly isLink: _angular_core.Signal<boolean>;
+    /** Whether this item is a dropdown type. */
+    readonly isDropdown: _angular_core.Signal<boolean>;
+    /** Whether this item is a custom type. */
+    readonly isCustom: _angular_core.Signal<boolean>;
+    /** Resolved route for routerLink binding. */
+    readonly resolvedRoute: _angular_core.Signal<string[] | null>;
+    /** Template context for custom item templates. */
+    readonly templateContext: _angular_core.Signal<{
+        $implicit: HubNavItem;
+        active: boolean;
+        expanded: boolean;
+        depth: number;
+    }>;
+    /**
+     * Whether the dropdown caret should be visible for this item.
+     * In panel mode, caret is hidden because expansion happens in side panels.
+     */
+    readonly showCaret: _angular_core.Signal<boolean>;
+    /**
+     * Handles click events on the item.
+     * Delegates to dropdown toggle or emits a click event depending on item type.
+     *
+     * @param event - The original DOM event.
+     */
+    onItemClick(event: Event): void;
+    /**
+     * Handles clicks on the label/link area of a routable dropdown item.
+     * In this case the click only performs navigation and does not toggle
+     * the submenu; submenu expansion is delegated to the dedicated caret.
+     *
+     * @param event - The original DOM event.
+     */
+    onRouteItemClick(event: Event): void;
+    /**
+     * Handles clicks on the dedicated caret button for routable dropdown items.
+     * The caret only toggles submenu visibility and must never trigger routing.
+     *
+     * @param event - The original DOM event.
+     */
+    onCaretClick(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubNavItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HubNavItemComponent, "hub-nav-item", never, { "item": { "alias": "item"; "required": true; "isSignal": true; }; "depth": { "alias": "depth"; "required": false; "isSignal": true; }; "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; "isExpanded": { "alias": "isExpanded"; "required": false; "isSignal": true; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; "isSignal": true; }; "forceAccordionMode": { "alias": "forceAccordionMode"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; "toggleDropdown": "toggleDropdown"; }, never, never, true, never>;
+}
+
+/**
+ * Renders a list of navigation items at a given depth level.
+ * Self-recursive: when an item has children and its dropdown is open,
+ * this component renders another `hub-nav-item-list` for the children.
+ *
+ * Includes keyboard navigation following WAI-ARIA menubar/menu patterns.
+ *
+ * @internal Used internally by `HubNavComponent`.
+ */
+declare class HubNavItemListComponent implements OnInit, OnDestroy {
+    /** The list of items to render. */
+    readonly items: _angular_core.InputSignal<HubNavItem[]>;
+    /** Nesting depth (0 = root level). */
+    readonly depth: _angular_core.InputSignal<number>;
+    /** Optional custom template for rendering item content. */
+    readonly itemTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    /**
+     * Forces all nested items in this list to use accordion expansion.
+     * Primarily used by the collapsed/mobile panel to avoid flyout/panel
+     * behaviors that are not suitable for small viewports.
+     */
+    readonly forceAccordionMode: _angular_core.InputSignal<boolean>;
+    /** Emitted when any item in the list is clicked. */
+    readonly itemClick: _angular_core.OutputEmitterRef<{
+        item: HubNavItem;
+        event: Event;
+    }>;
+    /** Emitted when a dropdown toggle is requested. */
+    readonly dropdownToggle: _angular_core.OutputEmitterRef<HubNavItem>;
+    /** Emitted when an item with panel expand mode is clicked and needs a new panel. */
+    readonly panelOpen: _angular_core.OutputEmitterRef<HubNavItem>;
+    /** Reference to the nav state service. */
+    readonly state: HubNavStateService;
+    /** Reference to the Angular router for active state detection. */
+    private readonly router;
+    /** Reactive URL value used to recompute active states on navigation changes. */
+    private readonly currentUrl;
+    /** Router events subscription lifecycle handle. */
+    private routerSub?;
+    /** Host element reference. */
+    private readonly el;
+    /**
+     * Whether children should render in accordion mode (inline with indentation).
+     * True when orientation is vertical and expand mode is 'accordion'.
+     */
+    readonly isAccordionMode: _angular_core.Signal<boolean>;
+    /** Whether this is a horizontal root-level nav (affects arrow key mapping). */
+    private get isHorizontalRoot();
+    /**
+     * Checks if the given item or any of its descendants is currently active.
+     *
+     * @param item - The item to check.
+     * @returns `true` if the item or a descendant matches the current route.
+     */
+    isItemActive(item: HubNavItem): boolean;
+    /** @inheritDoc */
+    ngOnInit(): void;
+    /** @inheritDoc */
+    ngOnDestroy(): void;
+    /**
+     * Checks if a dropdown is currently expanded.
+     *
+     * @param item - The dropdown item to check.
+     * @returns `true` if the dropdown is open.
+     */
+    isExpanded(item: HubNavItem): boolean;
+    /**
+     * Whether the given item has child items.
+     *
+     * @param item - The item to check.
+     * @returns `true` if the item has children.
+     */
+    hasChildren(item: HubNavItem): boolean;
+    /**
+     * Resolves the effective expand mode for an item.
+     * Considers per-item override, global config, and mobile fallback.
+     *
+     * @param item - The item to resolve the expand mode for.
+     * @returns The effective expand mode.
+     */
+    getItemExpandMode(item: HubNavItem): HubNavVerticalExpandMode;
+    /**
+     * Handles click events from a child item component.
+     *
+     * @param payload - The item and original event.
+     */
+    onItemClick(payload: {
+        item: HubNavItem;
+        event: Event;
+    }): void;
+    /**
+     * Handles dropdown toggle events from a child item component.
+     * In panel mode, emits `panelOpen` instead of toggling the dropdown.
+     *
+     * @param item - The dropdown item to toggle.
+     */
+    onDropdownToggle(item: HubNavItem): void;
+    /**
+     * Handles hover enter events on items with children.
+     * Opens the dropdown if the trigger mode includes hover.
+     *
+     * @param item - The hovered item.
+     */
+    onItemMouseEnter(item: HubNavItem): void;
+    /**
+     * Handles hover leave events on items with children.
+     * Closes the dropdown if the trigger mode includes hover.
+     *
+     * @param item - The item that lost hover.
+     */
+    onItemMouseLeave(item: HubNavItem): void;
+    /**
+     * Handles keyboard events for accessible navigation.
+     *
+     * @param event - The keyboard event.
+     */
+    onKeyDown(event: KeyboardEvent): void;
+    /** Returns all focusable item elements (direct children only). */
+    private getFocusableItems;
+    /** Returns the index of the currently focused item. */
+    private getCurrentFocusIndex;
+    /** Moves focus to the item at the given index (wraps around). */
+    private focusItem;
+    /** Opens the dropdown of the focused item and focuses its first child. */
+    private openFocusedDropdown;
+    /** Closes the dropdown of the focused item. */
+    private closeFocusedDropdown;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubNavItemListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HubNavItemListComponent, "hub-nav-item-list", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "depth": { "alias": "depth"; "required": false; "isSignal": true; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; "isSignal": true; }; "forceAccordionMode": { "alias": "forceAccordionMode"; "required": false; "isSignal": true; }; }, { "itemClick": "itemClick"; "dropdownToggle": "dropdownToggle"; "panelOpen": "panelOpen"; }, never, never, true, never>;
+}
+
+/**
+ * Visual separator between navigation item groups.
+ * Renders as a horizontal rule in vertical list contexts.
+ * Root horizontal nav bars hide separators because structural grouping
+ * should not consume inline menu space there.
+ *
+ * @internal This component is used internally by `HubNavItemListComponent`.
+ */
+declare class HubNavSeparatorComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubNavSeparatorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HubNavSeparatorComponent, "hub-nav-separator", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Renders a single side panel in the stacked panel navigation.
+ * Contains a header with the parent item's label (plus back/close buttons)
+ * and a body with a `hub-nav-item-list` for the panel's items.
+ *
+ * Includes keyboard navigation:
+ * - **Escape**: closes the panel and returns focus to the parent trigger.
+ * - **ArrowLeft**: navigates back (if drill-down) or closes the panel.
+ *
+ * @internal Used internally by `HubNavPanelContainerComponent`.
+ */
+declare class HubNavPanelComponent {
+    /** The panel state to render. */
+    readonly panel: _angular_core.InputSignal<HubNavPanelState>;
+    /** Width of this panel (CSS value). */
+    readonly panelWidth: _angular_core.InputSignal<string>;
+    /** Optional custom template for rendering item content. */
+    readonly itemTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    /**
+     * Controls whether the panel header is rendered.
+     * Used by horizontal layouts to avoid duplicating the selected root item
+     * title when that item is already visible in the top row.
+     */
+    readonly showHeader: _angular_core.InputSignal<boolean>;
+    /** Emitted when the panel close button is clicked. Carries the panel ID. */
+    readonly closePanel: _angular_core.OutputEmitterRef<string>;
+    /** Emitted when the back button is clicked. Carries the panel ID. */
+    readonly backClick: _angular_core.OutputEmitterRef<string>;
+    /** Emitted when an item in the panel is clicked. */
+    readonly itemClick: _angular_core.OutputEmitterRef<{
+        item: HubNavItem;
+        event: Event;
+    }>;
+    /** Emitted when a dropdown toggle is requested within the panel. */
+    readonly dropdownToggle: _angular_core.OutputEmitterRef<HubNavItem>;
+    /** Emitted when an item with panel expand mode is clicked (needs a new panel). */
+    readonly panelOpen: _angular_core.OutputEmitterRef<HubNavItem>;
+    /** Host element reference. */
+    private readonly el;
+    /** The label displayed in the panel header. */
+    readonly currentLabel: _angular_core.Signal<string>;
+    /** Accessible label for the panel navigation landmark. */
+    readonly ariaLabel: _angular_core.Signal<string>;
+    /**
+     * Handles keyboard events for panel navigation.
+     *
+     * @param event - The keyboard event.
+     */
+    onKeyDown(event: KeyboardEvent): void;
+    /**
+     * Handles close button click.
+     */
+    onCloseClick(): void;
+    /**
+     * Handles back button click for drill-down navigation.
+     */
+    onBackClick(): void;
+    /**
+     * Forwards item click events from the inner item list.
+     *
+     * @param payload - The clicked item and DOM event.
+     */
+    onItemClick(payload: {
+        item: HubNavItem;
+        event: Event;
+    }): void;
+    /**
+     * Forwards dropdown toggle events from the inner item list.
+     *
+     * @param item - The dropdown item that was toggled.
+     */
+    onDropdownToggle(item: HubNavItem): void;
+    /**
+     * Forwards panel open events from the inner item list.
+     *
+     * @param item - The item requesting a new panel.
+     */
+    onPanelOpen(item: HubNavItem): void;
+    /**
+     * Focuses the first focusable item inside this panel.
+     */
+    focusFirstItem(): void;
+    /**
+     * Checks whether the event target is a direct child of this panel's item-list
+     * (not inside a nested flyout/accordion submenu rendered by descendants).
+     *
+     * @param target - The DOM element that received the event.
+     * @returns `true` if the target belongs directly to this panel's navigation items.
+     */
+    private isDirectPanelFocus;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubNavPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HubNavPanelComponent, "hub-nav-panel", never, { "panel": { "alias": "panel"; "required": true; "isSignal": true; }; "panelWidth": { "alias": "panelWidth"; "required": false; "isSignal": true; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; "isSignal": true; }; "showHeader": { "alias": "showHeader"; "required": false; "isSignal": true; }; }, { "closePanel": "closePanel"; "backClick": "backClick"; "itemClick": "itemClick"; "dropdownToggle": "dropdownToggle"; "panelOpen": "panelOpen"; }, never, never, true, never>;
+}
+
+/**
+ * Container that renders the stack of side panels in a horizontal flex layout.
+ * Panels are stacked left-to-right or right-to-left depending on `sidebarSide`.
+ *
+ * @internal Used internally by `HubNavComponent`.
+ */
+declare class HubNavPanelContainerComponent {
+    /** Array of panel states to render. */
+    readonly panels: _angular_core.InputSignal<HubNavPanelState[]>;
+    /** Physical side where the sidebar is placed. */
+    readonly sidebarSide: _angular_core.InputSignal<HubNavSidebarSide>;
+    /** Width for each panel. */
+    readonly panelWidth: _angular_core.InputSignal<string>;
+    /** Optional custom template for rendering item content. */
+    readonly itemTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    /**
+     * When true, the first panel hides its header while it is not in drill-down
+     * mode. This is primarily used by horizontal nav where the selected root
+     * item is already visible in the top row.
+     */
+    readonly hideFirstPanelHeader: _angular_core.InputSignal<boolean>;
+    /** Emitted when a panel close button is clicked. Carries the panel ID. */
+    readonly panelClose: _angular_core.OutputEmitterRef<string>;
+    /** Emitted when a panel back button is clicked. Carries the panel ID. */
+    readonly panelBack: _angular_core.OutputEmitterRef<string>;
+    /** Emitted when an item inside a panel is clicked. */
+    readonly itemClick: _angular_core.OutputEmitterRef<{
+        item: HubNavItem;
+        event: Event;
+    }>;
+    /** Emitted when a dropdown toggle is requested inside a panel. */
+    readonly dropdownToggle: _angular_core.OutputEmitterRef<HubNavItem>;
+    /** Emitted when an item inside a panel requests a new panel. */
+    readonly panelOpen: _angular_core.OutputEmitterRef<HubNavItem>;
+    /**
+     * Resolves whether a panel header should be rendered for a given index.
+     *
+     * When `hideFirstPanelHeader` is true (used in layouts where parent context
+     * is always visible as a sibling column), headers are suppressed on all panels
+     * that are not in drill-down mode. A header is only shown when the panel is in
+     * drill-down mode — meaning its parent level has been replaced and is no longer
+     * visible.
+     *
+     * @param index - Zero-based panel index in the rendered stack.
+     * @param panel - Panel state at the given index.
+     * @returns `true` when the header should be visible.
+     */
+    shouldShowHeader(index: number, panel: HubNavPanelState): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HubNavPanelContainerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HubNavPanelContainerComponent, "hub-nav-panel-container", never, { "panels": { "alias": "panels"; "required": true; "isSignal": true; }; "sidebarSide": { "alias": "sidebarSide"; "required": false; "isSignal": true; }; "panelWidth": { "alias": "panelWidth"; "required": false; "isSignal": true; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; "isSignal": true; }; "hideFirstPanelHeader": { "alias": "hideFirstPanelHeader"; "required": false; "isSignal": true; }; }, { "panelClose": "panelClose"; "panelBack": "panelBack"; "itemClick": "itemClick"; "dropdownToggle": "dropdownToggle"; "panelOpen": "panelOpen"; }, never, never, true, never>;
+}
+
+export { HUB_NAV_CONFIG, HubNavComponent, HubNavConfigService, HubNavEndDirective, HubNavItemComponent, HubNavItemListComponent, HubNavItemTemplateDirective, HubNavPanelComponent, HubNavPanelContainerComponent, HubNavScrollSpyDirective, HubNavScrollSpySectionDirective, HubNavSeparatorComponent, HubNavStartDirective, HubNavStateService };
+export type { HubNavCollapseMode, HubNavConfig, HubNavDropdownEvent, HubNavDropdownTrigger, HubNavEndTemplateContext, HubNavItem, HubNavItemClickEvent, HubNavItemTemplateContext, HubNavItemType, HubNavOffcanvasPosition, HubNavOrientation, HubNavPanelAction, HubNavPanelEvent, HubNavPanelHistoryEntry, HubNavPanelState, HubNavPosition, HubNavSidebarSide, HubNavStartTemplateContext, HubNavVerticalExpandMode };