import * as _angular_core from '@angular/core';
import { ElementRef, Signal, OnDestroy, TemplateRef, OnChanges, AfterViewInit, EventEmitter, SimpleChanges, QueryList, WritableSignal, DestroyRef, AfterContentInit, OnInit } from '@angular/core';
import { Nullable as Nullable$1 } from '@fundamental-ngx/cdk';
import { FocusableOption, FocusOrigin } from '@angular/cdk/a11y';
import { HasElementRef, Nullable, CssClassBuilder } from '@fundamental-ngx/cdk/utils';
import { PopoverComponent } from '@fundamental-ngx/core/popover';
import { Placement } from '@fundamental-ngx/core/shared';
import * as i1 from '@angular/router';
import { RouterLink } from '@angular/router';
import { IconFont } from '@fundamental-ngx/core/icon';
import { Subject, Observable } from 'rxjs';
import * as i1$1 from '@fundamental-ngx/core/scrollbar';
import { FdbViewMode } from '@fundamental-ngx/btp/shared';
import { BaseDataSource, AbstractDataProvider, DataSourceParser, DataSourceDirective } from '@fundamental-ngx/cdk/data-source';

declare abstract class FdbNavigationItemLink implements HasElementRef {
    abstract elementRef: ElementRef<HTMLLinkElement>;
    abstract inPopover: boolean;
    abstract isActive$: Signal<boolean | undefined>;
    abstract routerLink: Nullable<RouterLink>;
}

declare class NavigationLinkRefDirective {
    /** Link template ref. */
    readonly templateRef: TemplateRef<any>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationLinkRefDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavigationLinkRefDirective, "[fdbNavigationLinkRef]", never, {}, {}, never, never, true, never>;
}
declare class NavigationLinkComponent extends FdbNavigationItemLink implements OnDestroy {
    /** @hidden */
    class: Nullable$1<string>;
    /** Link glyph */
    glyph: Nullable$1<string>;
    /** Glyph font family */
    glyphFont: IconFont;
    /** Whether the link is for the external resource. */
    external: boolean;
    /** Whether it's a quick create button. */
    quickCreate: boolean;
    /** Whether the link is inside popover. */
    get inPopover(): boolean;
    /** Element reference. */
    readonly elementRef: ElementRef<HTMLLinkElement>;
    /** @hidden */
    readonly isActive$: Signal<boolean | undefined>;
    /** @hidden */
    readonly _listItemComponent: FdbNavigationListItem | null;
    /** Router link reference. Used to determine whether the list item should be rendered with external expansion button. */
    readonly routerLink: RouterLink | null;
    /** @hidden */
    private readonly _routerLinkActive;
    /** @hidden */
    private readonly _rtl;
    /** @hidden */
    private readonly _navigation;
    /** @hidden */
    private _renderer;
    /** @hidden */
    private _tabIndexEffect;
    /** @hidden */
    constructor();
    /** @hidden */
    protected _clickHandler(event: Event): void;
    /** @hidden */
    protected _keyDownHandler(event: Event): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** @hidden */
    private _updateTabIndex;
    /** @hidden */
    private _canItemBeSelected;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationLinkComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavigationLinkComponent, "a[fdb-navigation-link], button[fdb-navigation-link]", never, { "class": { "alias": "class"; "required": false; }; "glyph": { "alias": "glyph"; "required": false; }; "glyphFont": { "alias": "glyphFont"; "required": false; }; "external": { "alias": "external"; "required": false; }; "quickCreate": { "alias": "quickCreate"; "required": false; }; }, {}, never, ["*"], true, [{ directive: typeof i1.RouterLinkActive; inputs: {}; outputs: {}; }]>;
    static ngAcceptInputType_quickCreate: unknown;
}

declare class NavigationListComponent implements OnChanges, AfterViewInit, OnDestroy {
    /** @hidden */
    set _listItems(value: Nullable$1<FdbNavigationListItem>[]);
    get _listItems(): Nullable$1<FdbNavigationListItem>[];
    /** List Role. */
    get _role(): 'tree' | 'menubar' | 'group' | 'menu';
    role: 'tree' | 'menubar' | 'group' | 'menu';
    /**
     * aria-label for the navigation list.
     */
    ariaLabel: Nullable$1<string>;
    /**
     * aria-roledescription for the navigation list.
     */
    ariaRoleDescription: Nullable$1<string>;
    /** Whether the list is for parent items. */
    parentItems: boolean;
    /** Whether the list is for child items. */
    childItems: boolean;
    /** Whether the list should not grow in height. */
    noGrow: boolean;
    /** Whether the list should handle keyboard navigation. */
    withKeyboardNavigation: boolean;
    /** Reference to the More button component if this list is inside a More button popover. */
    moreButtonRef: any;
    /** Event emitted when user tries to navigate to the item before the list itself. */
    focusBefore: EventEmitter<void>;
    /** Event emitted when user tries to navigate to the item after the list itself. */
    focusAfter: EventEmitter<void>;
    /** Computed role based on navigation state and input role. */
    readonly computedRole: _angular_core.Signal<"menu" | "tree" | "menubar" | "group">;
    /** Computed aria-label for group lists based on parent item's text content. */
    readonly computedAriaLabel: _angular_core.Signal<Nullable$1<string>>;
    /** List items. */
    readonly listItems$: _angular_core.WritableSignal<Nullable$1<FdbNavigationListItem>[]>;
    /** @hidden */
    private _listItemsArray;
    /** @hidden */
    private _keyManager;
    /** @hidden */
    private readonly _navigationService;
    /**
     * @hidden
     * Parent navigation component.
     */
    private readonly _navigation;
    /**
     * @hidden
     * Parent list item.
     */
    private readonly _listItem;
    /** @hidden */
    private readonly _rtlService;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    private get _activeItemIndex();
    /** @hidden */
    private _renderer;
    /** @hidden */
    private _elementRef;
    /** @hidden */
    private _ariaLabelEffect;
    /** @hidden */
    constructor();
    /**
     * @hidden
     * Handler for keyboard navigation.
     */
    _keydownHandler(event: KeyboardEvent): void;
    /** @hidden */
    setActiveItemIndex(index: number): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngOnChanges(changes: SimpleChanges): void;
    /** @hidden */
    ngOnDestroy(): void;
    /**
     * Updates aria-label attribute manually to avoid expression changed errors
     */
    private _updateAriaLabel;
    /** @hidden */
    private _setupKeyManager;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationListComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavigationListComponent, "ul[fdb-navigation-list]", never, { "_listItems": { "alias": "listItems"; "required": false; }; "role": { "alias": "role"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "ariaRoleDescription": { "alias": "ariaRoleDescription"; "required": false; }; "parentItems": { "alias": "parentItems"; "required": false; }; "childItems": { "alias": "childItems"; "required": false; }; "noGrow": { "alias": "noGrow"; "required": false; }; "withKeyboardNavigation": { "alias": "withKeyboardNavigation"; "required": false; }; "moreButtonRef": { "alias": "moreButtonRef"; "required": false; }; }, { "focusBefore": "focusBefore"; "focusAfter": "focusAfter"; }, never, ["*"], true, never>;
    static ngAcceptInputType_parentItems: unknown;
    static ngAcceptInputType_childItems: unknown;
    static ngAcceptInputType_noGrow: unknown;
    static ngAcceptInputType_withKeyboardNavigation: unknown;
}

declare class NavigationListItemMarkerDirective implements HasElementRef {
    /** Element reference. */
    readonly elementRef: ElementRef<any>;
    /** @hidden */
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationListItemMarkerDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavigationListItemMarkerDirective, "[fdbNavigationListItemMarker]", never, {}, {}, never, never, true, never>;
}
declare class NavigationListItemComponent extends FdbNavigationListItem implements AfterViewInit, OnDestroy {
    /** @hidden */
    set class(value: Nullable<string>);
    get class(): Nullable<string>;
    /** Whether the list item represents "Home" item. */
    set home(value: boolean);
    get home(): boolean;
    /** Whether the list item represents "Quick create" button. */
    set quickCreate(value: boolean);
    get quickCreate(): boolean;
    /** Whether the list item should be rendered as a separator */
    set separator(value: boolean);
    get separator(): boolean;
    /** Whether the list item should be rendered as a spacer */
    set spacer(value: boolean);
    get spacer(): boolean;
    /** Whether the list item should be rendered as a group. */
    set group(group: boolean);
    get group(): boolean;
    /** Whether the list item is expanded. */
    set expanded(expanded: boolean);
    get expanded(): boolean;
    /** Whether the item should be marked as selected. */
    set selected(selected: boolean);
    get selected(): boolean;
    /** Whether the item is disabled. */
    set disabled(disabled: boolean);
    get disabled(): boolean;
    /** @hidden */
    listItems: QueryList<FdbNavigationListItem>;
    /** Link reference. */
    set link(value: Nullable<FdbNavigationItemLink>);
    /**
     * Link template reference.
     */
    linkRef: Nullable<NavigationLinkRefDirective>;
    /** Renderer template reference. */
    set renderer(renderer: TemplateRef<any> | undefined);
    /** ID for the navigation list item. Default one is assigned if not provided. */
    id: _angular_core.InputSignal<string>;
    /** Type of the list item. Whether its a standard item or a "show more" button container. */
    readonly type: 'item' | 'showMore';
    /** List item placement container. */
    readonly placementContainer: FdbNavigationContentContainer | undefined;
    /**
     * Whether the list item is visible in the main navigation list container.
     */
    readonly isVisible$: _angular_core.Signal<boolean>;
    /** Whether the item is disabled. Cached to avoid repeated signal calls. */
    readonly _isDisabledCached$: _angular_core.Signal<boolean>;
    /**
     * Whether the item is navigatable via the keyboard.
     */
    get skipNavigation(): boolean;
    /** aria-expanded attribute value. */
    readonly expandedAttr$: _angular_core.Signal<boolean>;
    /** Role attribute value based on navigation state. */
    readonly roleAttr$: _angular_core.Signal<"treeitem" | "menuitem" | "menuitemradio">;
    /** aria-checked attribute value for menuitemradio role. */
    readonly ariaCheckedAttr$: _angular_core.Signal<any>;
    /** aria-selected attribute value - kept in both expanded and snapped modes. */
    readonly ariaSelectedAttr$: _angular_core.Signal<any>;
    /** aria-level attribute value - only for treeitem role. */
    readonly ariaLevelAttr$: _angular_core.Signal<any>;
    /** aria-owns attribute value for items with children. */
    readonly ariaOwnsAttr$: _angular_core.Signal<string | undefined>;
    /** ID attribute for child lists. */
    readonly childListIdAttr$: _angular_core.Signal<string | undefined>;
    /** aria-label attribute value for snapped mode menuitemradio. */
    readonly ariaLabelAttr$: _angular_core.Signal<string | undefined>;
    /** Expander aria-label attribute value. */
    readonly expanderAriaLabelAttr$: _angular_core.Signal<string>;
    /** aria-haspopup attribute value for snapped mode items with children. */
    readonly ariaHasPopupAttr$: _angular_core.Signal<"menu" | "dialog" | undefined>;
    /** aria-current attribute value for snapped mode items with children. */
    readonly ariaCurrentAttr$: _angular_core.Signal<"page" | undefined>;
    /** Wrapper role attribute for snapped mode popovers. */
    readonly wrapperRoleAttr$: _angular_core.Signal<"tree" | undefined>;
    /** Wrapper aria-roledescription for snapped mode popovers. */
    readonly wrapperAriaRoleDescriptionAttr$: _angular_core.Signal<string | undefined>;
    /** Title item role for snapped mode - should be treeitem in popovers. */
    readonly titleItemRoleAttr$: _angular_core.Signal<"treeitem" | "menuitem" | "menuitemradio">;
    /** Title item aria-selected for snapped mode - should not be selected if children are selected. */
    readonly titleItemAriaSelectedAttr$: _angular_core.Signal<any>;
    readonly titleItemFocusable$: _angular_core.Signal<any>;
    /** CSS Class signal. */
    readonly class$: _angular_core.Signal<string>;
    /** Combined selected state - considers both manual selection and service selection. */
    readonly selected$: any;
    /** @hidden */
    readonly quickCreate$: _angular_core.WritableSignal<boolean>;
    /** @hidden */
    readonly _moreButtonRef$: _angular_core.Signal<any>;
    /** Optional parent list component. */
    readonly parentListItemComponent: FdbNavigationListItemCmp | null;
    /** @hidden */
    get parentListItem(): FdbNavigationListItem | null;
    /**
     * @hidden
     * Popover position. Changes based on rtl value.
     */
    protected readonly popoverPlacement: _angular_core.Signal<Placement>;
    /** @hidden Max-height for the overflow submenu, computed dynamically based on viewport position. */
    protected readonly overflowSubmenuMaxHeight: _angular_core.WritableSignal<string | null>;
    /** @hidden */
    private readonly _home$;
    /** Manual selection state signal (for router-based selection mode). */
    private readonly _manuallySelected$;
    /** @hidden */
    private readonly _class$;
    /** @hidden */
    private readonly _separator$;
    /** @hidden */
    private readonly _spacer$;
    /** @hidden */
    private readonly _links;
    /** @hidden */
    private readonly _childLists;
    /** @hidden */
    private _keyManager;
    /** @hidden */
    private readonly _injector;
    /** @hidden */
    private readonly _langSignal;
    /** @hidden */
    private _translationResolver;
    /** Translation signal for snapped popover role description. */
    private readonly _snappedPopoverRoleDescription$;
    /** Translation signal for expander aria-label. */
    private readonly _expanderAriaLabel$;
    private readonly _rtlService;
    /** @hidden */
    private readonly _isRtl;
    /**
     * @hidden
     * Directive that used during data-driven rendering.
     */
    private readonly _parentNavigationListItemDirective;
    /** @hidden */
    private readonly _parentNavigationService;
    /** @hidden */
    private readonly _parentNavigationList;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    private readonly _itemContainer;
    /** @hidden */
    private readonly _overflowSubmenuContainer;
    /** @hidden */
    constructor();
    /** @hidden */
    ngOnDestroy(): void;
    /** @hidden */
    _focusBeforeList(): void;
    /**
     * @hidden
     * When item is focused, we notify list container about it to update active index in FocusKeyManager.
     */
    _focusInHandler(): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    registerLink(link: FdbNavigationItemLink): void;
    /** @hidden */
    unregisterLink(link: FdbNavigationItemLink): void;
    /** @hidden */
    registerChildList(list: NavigationListComponent): void;
    /** @hidden */
    unregisterChildList(list: NavigationListComponent): void;
    /** @hidden */
    handleHorizontalNavigation(isExpand: boolean): void;
    /**
     * Callback method when Arrow down is pressed on the link in popover.
     */
    popoverLinkArrowDown(): void;
    /** @Hidden */
    _innerListKeydown(event: KeyboardEvent): void;
    /** Toggles expanded state of the item. */
    toggleExpanded(): void;
    /** Handles item click for both selection and expansion based on item type and navigation mode. */
    handleItemClick(): void;
    /** Handles keydown events for navigation item actions. */
    handleItemKeydown(event: KeyboardEvent): void;
    /** Callback method when user used keyboard arrows to expand/collapse list item. */
    keyboardExpanded(shouldExpand: boolean): void;
    /**
     * Focus method implementation.
     * Used by main navigation component FocusKeyManager.
     * @param origin
     */
    focus(): void;
    /**
     * Focuses inner link element.
     * Optionally closes the popover.
     */
    focusLink(closePopover?: boolean): void;
    /** @hidden */
    _onPopoverOpen(isOpen: boolean, popover: PopoverComponent): void;
    /**
     * Determines if this item can be selected based on its type and structure.
     * @returns true if the item can be selected, false otherwise
     */
    canItemBeSelected(): boolean;
    /**
     * @hidden
     * Handles mouseenter on overflow items to dynamically adjust the submenu max-height.
     * Uses requestAnimationFrame to ensure the browser has laid out the submenu
     * (which transitions from display:none to display:block via CSS :hover)
     * before measuring its viewport position.
     */
    onOverflowItemMouseEnter(): void;
    private _focusPopoverLink;
    /** @hidden */
    private _ensureChildTabindexUpdated;
    /** @hidden */
    private _visibleItemKeyboardExpandedHandler;
    /** @hidden */
    private _snappedItemKeyboardExpandedHandler;
    /**
     * @hidden
     * Method used to handle keyboard navigation for list item that is inside overflow container.
     */
    private _overflowItemKeyboardExpandedHandler;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationListItemComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavigationListItemComponent, "fdb-navigation-list-item", never, { "class": { "alias": "class"; "required": false; }; "home": { "alias": "home"; "required": false; }; "quickCreate": { "alias": "quickCreate"; "required": false; }; "separator": { "alias": "separator"; "required": false; }; "spacer": { "alias": "spacer"; "required": false; }; "group": { "alias": "group"; "required": false; }; "expanded": { "alias": "expanded"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, ["link", "linkRef", "listItems"], never, true, never>;
    static ngAcceptInputType_home: unknown;
    static ngAcceptInputType_quickCreate: unknown;
    static ngAcceptInputType_separator: unknown;
    static ngAcceptInputType_spacer: unknown;
    static ngAcceptInputType_group: unknown;
    static ngAcceptInputType_expanded: unknown;
    static ngAcceptInputType_selected: unknown;
    static ngAcceptInputType_disabled: unknown;
}

declare class NavigationService {
    /** Currently active list item. */
    currentItem$: Subject<FdbNavigationListItem>;
    /** Currently selected item (for click-based selection mode). */
    selectedItem$: _angular_core.WritableSignal<FdbNavigationListItem | null>;
    /** Subject to notify when an overflow item is selected and should be promoted. */
    overflowItemSelected$: Subject<FdbNavigationListItem>;
    /** Subject to notify when selection changes to clear manual selections */
    selectionChanged$: Subject<FdbNavigationListItem | null>;
    /**
     * Set the selected item.
     * @param item The item to select, or null to clear selection.
     */
    setSelectedItem(item: FdbNavigationListItem | null): void;
    /**
     * Get the currently selected item.
     * @returns The currently selected item, or null if none is selected.
     */
    getSelectedItem(): FdbNavigationListItem | null;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NavigationService>;
}

declare abstract class FdbNavigation {
    abstract classList$: Signal<string[]>;
    abstract isSnapped$: Signal<boolean>;
    abstract showMoreButton$: WritableSignal<Nullable<FdbNavigationListItem>>;
    abstract _navigationItemRenderer: Signal<any>;
    abstract closeAllPopups: Subject<void>;
    abstract selectionMode: 'router' | 'click';
    abstract service: NavigationService;
    abstract setActiveItem(value: FdbNavigationListItem | null): void;
    abstract getActiveItem(): FdbNavigationListItem | null;
    abstract closePopups(): void;
}

declare const LIST_ITEM_CLASS = "fd-navigation__list-item";
declare abstract class FdbNavigationListItem implements FocusableOption {
    abstract type: 'item' | 'showMore';
    abstract separator: boolean;
    abstract spacer: boolean;
    abstract home: boolean;
    abstract isVisible$: Signal<boolean>;
    abstract skipNavigation: boolean;
    abstract placementContainer?: FdbNavigationContentContainer;
    abstract parentListItemComponent: FdbNavigationListItemCmp | null;
    abstract parentListItem: FdbNavigationListItem | null;
    abstract class$: Signal<string>;
    abstract selected$: Signal<boolean>;
    abstract id: Signal<string>;
    abstract focus(origin?: FocusOrigin | undefined): void;
    abstract toggleExpanded(): void;
    abstract keyboardExpanded(shouldExpand: boolean): void;
    abstract popoverLinkArrowDown(): void;
    abstract registerLink(link: FdbNavigationItemLink): void;
    abstract unregisterLink(link: FdbNavigationItemLink): void;
    abstract registerChildList(list: NavigationListComponent): void;
    abstract unregisterChildList(list: NavigationListComponent): void;
    abstract handleHorizontalNavigation(isExpand: boolean): void;
    abstract focusLink(closePopover?: boolean): void;
    abstract canItemBeSelected(): boolean;
    /** Marker directive that is attached to the rendered list item. */
    marker: Nullable<NavigationListItemMarkerDirective>;
    /** @hidden */
    readonly listItems$: _angular_core.WritableSignal<Nullable<FdbNavigationListItem>[]>;
    /** Whether item has child items. */
    readonly hasChildren$: Signal<boolean>;
    /** Whether popover is open. Applicable for snapped navigation state. */
    readonly popoverOpen$: _angular_core.WritableSignal<boolean>;
    /**
     * Link reference.
     */
    readonly link$: _angular_core.WritableSignal<Nullable<FdbNavigationItemLink>>;
    /**
     * Item content renderer.
     */
    readonly renderer$: _angular_core.WritableSignal<TemplateRef<any> | null>;
    /**
     * Whether the item should be hidden under "More" button.
     */
    readonly hidden$: _angular_core.WritableSignal<boolean>;
    /**
     * Whether the item is in overflow menu. Applicable only when the navigation is in snapped mode.
     */
    readonly isOverflow$: Signal<boolean>;
    /**
     * Item Hierarchy level in navigation tree.
     */
    readonly level$: any;
    /**
     * Normalized level. Calculated based on location of the item, whether it is inside group or not.
     * Can be different than `level$`.
     */
    readonly normalizedLevel$: any;
    /**
     * Whether the List item should be marked as selected.
     * Based on a `snapped` state will determine whether to highlight the link if it, or it's child links are active.
     */
    readonly isActiveAttr$: any;
    /**
     * Whether the item is inside group.
     */
    readonly inGroup$: any;
    /** @hidden */
    readonly expanded$: _angular_core.WritableSignal<boolean>;
    /** @hidden */
    readonly isGroup$: _angular_core.WritableSignal<boolean>;
    /** @hidden */
    readonly disabled$: _angular_core.WritableSignal<boolean>;
    /** Navigation container reference. */
    readonly navigation: FdbNavigation;
}
declare abstract class FdbNavigationListItemCmp extends FdbNavigationListItem {
}

declare abstract class FdbNavigationContentContainer {
    /**
     * List containing child list items that needs to be rendered. Can be different than `allListItems$`.
     */
    abstract listItems$: Signal<FdbNavigationListItem[]>;
    /**
     * Container placement in Navigation component.
     */
    abstract placement: 'start' | 'end';
    /**
     * List containing all child navigation list items.
     */
    readonly allListItems$: _angular_core.WritableSignal<FdbNavigationListItem[]>;
    /** @hidden */
    protected readonly _destroyRef: DestroyRef;
    /**
     * @hidden
     * List of registered navigation list items.
     * Used only with data-driven navigation component.
     */
    private readonly _registeredListItems;
    /**
     * Registers navigation list item.
     */
    registerItem(item: FdbNavigationListItem): void;
    /**
     * Unregisters navigation list item.
     */
    unregisterItem(item: FdbNavigationListItem): void;
}

declare class NavigationContentEndComponent extends FdbNavigationContentContainer implements AfterContentInit {
    /** Whether the list items are content-projected. Used only with data-driven navigation. */
    contentProjected: boolean;
    /**
     * aria-label for the navigation list.
     */
    ariaLabel: Nullable$1<string>;
    /**
     * aria-roledescription for the navigation list.
     */
    ariaRoleDescription: Nullable$1<string>;
    /** @hidden */
    private readonly _listItems;
    /** @hidden */
    readonly listItems$: _angular_core.WritableSignal<FdbNavigationListItem[]>;
    /** Whether the container is placed on the start position, or the end position of the navigation. */
    readonly placement: 'start' | 'end';
    /** @hidden */
    ngAfterContentInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationContentEndComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavigationContentEndComponent, "fdb-navigation-content-end", never, { "contentProjected": { "alias": "contentProjected"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "ariaRoleDescription": { "alias": "ariaRoleDescription"; "required": false; }; }, {}, ["_listItems"], never, true, never>;
}

declare class NavigationContentStartComponent extends FdbNavigationContentContainer implements AfterContentInit {
    /** Whether the list items are content-projected. Used only with data-driven navigation. */
    contentProjected: boolean;
    /**
     * aria-label for the navigation list.
     */
    ariaLabel: Nullable$1<string>;
    /**
     * aria-roledescription for the navigation list.
     */
    ariaRoleDescription: Nullable$1<string>;
    /** @hidden */
    private readonly _listItems;
    /** @hidden */
    private readonly _moreContainer;
    /** @hidden */
    private readonly _showMoreButton;
    /** Whether the container is placed on the start position, or the end position of the navigation. */
    readonly placement: 'start' | 'end';
    /** Navigation component reference. */
    readonly navigation: FdbNavigation;
    /** Inner List items that should be rendered. */
    readonly listItems$: _angular_core.Signal<FdbNavigationListItem[]>;
    /** @hidden */
    readonly _showMoreButton$: _angular_core.WritableSignal<boolean>;
    /** @hidden */
    readonly visibleItems$: _angular_core.WritableSignal<FdbNavigationListItem[]>;
    /** @hidden */
    readonly hiddenItems$: _angular_core.WritableSignal<FdbNavigationListItem[]>;
    /** @hidden */
    private _calculationInProgress;
    /** @hidden */
    private readonly _elementRef;
    /** @hidden */
    private readonly _isSnappedObservable;
    /** @hidden */
    private readonly _listItemsObservable;
    /** @hidden */
    private readonly _cdr;
    /** @hidden */
    ngAfterContentInit(): void;
    /**
     * @hidden
     * Calculates available space to fit the items.
     * Determines whether to show the "More" button if available space is not enough to fit all list items.
     */
    private _calculateVisibleItems;
    /**
     * @hidden
     * Promotes an overflow item to be the last visible item.
     * Moves the current last visible item to overflow while preserving overflow order.
     */
    private _promoteOverflowItem;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationContentStartComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavigationContentStartComponent, "fdb-navigation-content-start", never, { "contentProjected": { "alias": "contentProjected"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "ariaRoleDescription": { "alias": "ariaRoleDescription"; "required": false; }; }, {}, ["_listItems"], never, true, [{ directive: typeof i1$1.ScrollbarDirective; inputs: {}; outputs: {}; }]>;
}

declare class NavigationListItemDirective implements OnDestroy {
    /**
     * Injector used for rendering child list item component.
     * Allows list item component to inject parent list container and register itself as a child item.
     */
    readonly injector: _angular_core.DestroyableInjector;
    /** @hidden */
    readonly parentNavListItemDirective: NavigationListItemDirective | null;
    /**
     * Set of child directives.
     * Used to build hierarchy tree.
     */
    readonly childDirectives: _angular_core.WritableSignal<Set<NavigationListItemDirective>>;
    /**
     * @hidden
     * Navigation list item component instance.
     */
    _item: Nullable<FdbNavigationListItem>;
    /** @hidden */
    private readonly _contentContainer;
    /** @hidden */
    constructor();
    /**
     * Registers child list item component for further usage.
     * @param item
     */
    registerItem(item: FdbNavigationListItem): void;
    /**
     * Removes child list item.
     */
    unregisterItem(): void;
    /**
     * Registers child directive.
     */
    registerChildDirective(directive: NavigationListItemDirective): void;
    /** @hidden */
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationListItemDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavigationListItemDirective, "[fdbNavigationListItem]", ["fdbListItem"], {}, {}, never, never, true, never>;
}
declare class NavigationListItemRefDirective<T = any> {
    /** Type alias. */
    fdbNavigationListItemRefAs: T;
    /** Template reference. */
    readonly templateRef: TemplateRef<T>;
    /** @hidden */
    static ngTemplateContextGuard<T>(dir: NavigationListItemRefDirective<T>, ctx: unknown): ctx is {
        $implicit: T;
    };
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationListItemRefDirective<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavigationListItemRefDirective<any>, "[fdbNavigationListItemRef]", never, { "fdbNavigationListItemRefAs": { "alias": "fdbNavigationListItemRefAs"; "required": false; }; }, {}, never, never, true, never>;
}

type FdbNavigationType = 'horizontal' | 'vertical';
type FdbNavigationState = 'expanded' | 'snapped' | 'popup';

declare class NavigationComponent extends FdbNavigation implements CssClassBuilder, OnChanges, OnInit, AfterViewInit, OnDestroy {
    /** @hidden */
    class: string;
    /**
     * aria-label for the navigation.
     */
    ariaLabel: Nullable<string>;
    /**
     * aria-roledescription for the navigation.
     */
    ariaRoleDescription: Nullable<string>;
    /**
     * Navigation mode.
     */
    mode: FdbViewMode;
    /**
     * Whether the navigation is rendered as an overlay.
     */
    isOverlay: boolean;
    /**
     * Navigation state.
     */
    set state(value: FdbNavigationState);
    get state(): FdbNavigationState;
    /**
     * Navigation type.
     */
    type: FdbNavigationType;
    /**
     * Selection mode for navigation items.
     * - 'router': Selection is handled by router link activation (default)
     * - 'click': Selection is handled by click events
     */
    selectionMode: 'router' | 'click';
    /** @hidden */
    set _navigationItemRef(value: Nullable<NavigationListItemRefDirective>);
    /** @hidden */
    private readonly _navigationItems;
    /**
     * State signal.
     */
    readonly state$: _angular_core.WritableSignal<FdbNavigationState>;
    /**
     * Whether the navigation is in snapped mode.
     */
    readonly isSnapped$: _angular_core.Signal<boolean>;
    /**
     * Whether to show "More" button. Applicable for `snapped` state only.
     */
    readonly showMoreButton$: _angular_core.WritableSignal<Nullable<FdbNavigationListItem>>;
    /**
     * Signal for navigation classList.
     * Used by popover-based submenus.
     */
    readonly classList$: _angular_core.WritableSignal<string[]>;
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    /** Navigation service for managing selection state. */
    readonly service: NavigationService;
    /** @hidden */
    readonly _navigationItemRenderer: _angular_core.WritableSignal<NavigationListItemRefDirective<any> | null>;
    /** Stream notifies to close all popups in child list items. */
    readonly closeAllPopups: Subject<void>;
    /** @hidden */
    private readonly _viewInitiated$;
    /** @hidden */
    private _keyManager;
    /** @hidden */
    constructor();
    /** @hidden */
    buildComponentCssClass(): string[];
    /**
     * @hidden
     * Main keyboard navigation handler.
     */
    _keyDownHandler(event: KeyboardEvent): void;
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    ngOnChanges(): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /**
     * Returns currently focused list item.
     */
    getActiveItem(): FdbNavigationListItem | null;
    /**
     * Sets focused item.
     */
    setActiveItem(item: FdbNavigationListItem): void;
    /** Notifies child list items that all popups should be closed. */
    closePopups(): void;
    /**
     * Get the currently selected item when in click selection mode.
     * @returns The currently selected item, or null if none is selected.
     */
    getSelectedItem(): FdbNavigationListItem | null;
    /**
     * Set the selected item when in click selection mode.
     * @param item The item to select, or null to clear selection.
     */
    setSelectedItem(item: FdbNavigationListItem | null): void;
    /**
     * Clear the current selection when in click selection mode.
     */
    clearSelection(): void;
    /**
     * Get a navigation item by its ID.
     * @param id The ID of the navigation item to find.
     * @returns The navigation item with the specified ID, or null if not found.
     */
    getNavigationItemById(id: string): FdbNavigationListItem | null;
    /**
     * Set the selected item by its ID when in click selection mode.
     * @param id The ID of the navigation item to select.
     * @returns True if the item was found and selected, false otherwise.
     */
    setSelectedItemById(id: string): boolean;
    /**
     * Helper method to find an item by ID recursively through the navigation tree.
     * @param items Array of navigation items to search through.
     * @param id The ID to search for.
     * @returns The found item or null.
     */
    private _findItemById;
    /**
     * Updates the list of items.
     * Optionally inserts "More" button if overflow menu should be rendered.
     * @param showMoreButton Whether to add "More" button.
     */
    private _resetItemsList;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavigationComponent, "fdb-navigation", never, { "class": { "alias": "class"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "ariaRoleDescription": { "alias": "ariaRoleDescription"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "isOverlay": { "alias": "isOverlay"; "required": false; }; "state": { "alias": "state"; "required": false; }; "type": { "alias": "type"; "required": false; }; "selectionMode": { "alias": "selectionMode"; "required": false; }; }, {}, ["_navigationItemRef", "_navigationItems"], ["*"], true, never>;
    static ngAcceptInputType_isOverlay: unknown;
}

type NavigationDataSourceItem<T extends Record<string, any> = Record<string, any>> = {
    placement: 'start' | 'end';
    children?: NavigationDataSourceItem<T>[];
} & T;
declare class FdbNavigationDataSource<T extends NavigationDataSourceItem> extends BaseDataSource<T> {
    dataProvider: AbstractDataProvider<T>;
    /** @hidden */
    limitless: boolean;
    /** @hidden */
    constructor(dataProvider: AbstractDataProvider<T>);
}
declare class ArrayNavigationDataSource<T extends NavigationDataSourceItem> extends FdbNavigationDataSource<T> {
    /** @hidden */
    constructor(data: T[]);
}
declare class ObservableNavigationDataSDataSource<T extends NavigationDataSourceItem> extends FdbNavigationDataSource<T> {
    /** @hidden */
    constructor(data: Observable<T[]>);
}
/**
 * Type of acceptable objects as a datasource for the Navigation component.
 */
type FdbNavigationDataSAcceptableDataSource<T extends NavigationDataSourceItem> = FdbNavigationDataSource<T> | Observable<T[]> | T[];
declare class NavigationDataSourceParser<T extends NavigationDataSourceItem> implements DataSourceParser<T, FdbNavigationDataSource<T>> {
    /**
     * Transforms plain array or observable into DataSource class.
     * @param source
     */
    parse(source: FdbNavigationDataSAcceptableDataSource<T>): FdbNavigationDataSource<T> | undefined;
}

declare class NavigationListDataSourceDirective<T extends Record<string, any>> extends DataSourceDirective<NavigationDataSourceItem<T>, FdbNavigationDataSource<NavigationDataSourceItem<T>>> {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationListDataSourceDirective<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavigationListDataSourceDirective<any>, "fdb-navigation[dataSource]", never, {}, {}, never, never, true, never>;
}

interface NavigationMoreButtonRefContext {
    $implicit: () => void;
}
declare class NavigationMoreButtonComponent implements AfterViewInit {
    /** @hidden */
    listItems: FdbNavigationListItem[];
    /** @hidden */
    private readonly _link;
    /** @hidden */
    private readonly _popover;
    /** @hidden */
    private readonly _navigationList;
    /** @hidden */
    customMoreRenderer: Nullable$1<TemplateRef<any>>;
    /** Whether the show more is visible. */
    isVisible$: _angular_core.WritableSignal<boolean>;
    /** Whether popover is open. Applicable for snapped navigation state. */
    readonly popoverOpen$: _angular_core.WritableSignal<boolean>;
    /** ID for the more button. */
    readonly id: _angular_core.WritableSignal<string>;
    /** @hidden */
    readonly type = "showMore";
    /** @hidden */
    readonly placementContainer: undefined;
    /**
     * Whether the item is in overflow menu.
     */
    readonly isOverflow$: _angular_core.WritableSignal<boolean>;
    /** Whether item has child items. */
    readonly hasChildren$: _angular_core.WritableSignal<boolean>;
    /** @hidden */
    readonly _navigation: FdbNavigation;
    /**
     * Link reference.
     */
    readonly link$: _angular_core.WritableSignal<Nullable$1<FdbNavigationItemLink>>;
    /** More button aria-label attribute value. */
    readonly moreButtonAriaLabelAttr$: _angular_core.Signal<string>;
    /** Overflow menu aria-label attribute value. */
    readonly overflowMenuAriaLabelAttr$: _angular_core.Signal<string>;
    /**
     * @hidden
     * Popover position. Changes based on rtl value.
     */
    protected readonly popoverPlacement: _angular_core.Signal<Placement>;
    /** @hidden */
    private readonly _triggerElement;
    /** @hidden */
    private _popoverClicked;
    /** @hidden */
    private readonly elementRef;
    /** @hidden */
    private readonly _rtlService;
    /** @hidden */
    private readonly _isRtl;
    /** @hidden */
    private readonly _langSignal;
    /** @hidden */
    private _translationResolver;
    /** Translation signal for more button aria-label. */
    private readonly _moreButtonAriaLabel$;
    /** Translation signal for overflow menu aria-label. */
    private readonly _overflowMenuAriaLabel$;
    /** @hidden */
    constructor();
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    _onPopoverOpenChange(isOpen: boolean): void;
    /** @hidden */
    togglePopover(withClick?: boolean): void;
    /** @hidden */
    registerLink(): void;
    /** @hidden */
    unregisterLink(): void;
    /** @hidden */
    registerChildList(): void;
    /** @hidden */
    unregisterChildList(): void;
    /** @hidden */
    focus(): void;
    /**
     * Focuses inner link element.
     * Optionally closes the popover.
     */
    focusLink(closePopover?: boolean): void;
    /** @hidden */
    toggleExpanded(): void;
    /** @hidden */
    keyboardExpanded(shouldExpand: boolean): void;
    /** @hidden */
    _keydownPopoverToggle(event: KeyboardEvent): void;
    /** @hidden */
    canItemBeSelected(): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationMoreButtonComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavigationMoreButtonComponent, "li[fdb-navigation-more-button]", never, { "listItems": { "alias": "listItems"; "required": false; }; }, {}, never, never, true, never>;
}

declare const FDB_NAVIGATION: readonly [typeof NavigationComponent, typeof NavigationContentStartComponent, typeof NavigationContentEndComponent, typeof NavigationLinkComponent, typeof NavigationLinkRefDirective, typeof NavigationListItemComponent, typeof NavigationListItemRefDirective, typeof NavigationListDataSourceDirective];

export { ArrayNavigationDataSource, FDB_NAVIGATION, FdbNavigationContentContainer, FdbNavigationDataSource, FdbNavigationListItem, FdbNavigationListItemCmp, LIST_ITEM_CLASS, NavigationComponent, NavigationContentEndComponent, NavigationContentStartComponent, NavigationDataSourceParser, NavigationLinkComponent, NavigationLinkRefDirective, NavigationListComponent, NavigationListDataSourceDirective, NavigationListItemComponent, NavigationListItemDirective, NavigationListItemMarkerDirective, NavigationListItemRefDirective, NavigationMoreButtonComponent, ObservableNavigationDataSDataSource };
export type { FdbNavigationDataSAcceptableDataSource, FdbNavigationState, FdbNavigationType, NavigationDataSourceItem, NavigationMoreButtonRefContext };