import * as i5 from '@angular/cdk/portal';
import { CdkPortalOutlet, ComponentPortal, TemplatePortal, DomPortal } from '@angular/cdk/portal';
import * as i0 from '@angular/core';
import { OnDestroy, ComponentRef, EmbeddedViewRef, ElementRef, AfterViewInit, Renderer2, InputSignalWithTransform, InputSignal, OutputEmitterRef, ModelSignal, InjectionToken, AfterContentInit, TemplateRef, OnInit, OnChanges, EventEmitter, SimpleChanges, QueryList } from '@angular/core';
import { Observable, Subject } from 'rxjs';
import * as i2 from '@fundamental-ngx/cdk/utils';
import { HasElementRef, Nullable } from '@fundamental-ngx/cdk/utils';
import { ScrollStrategy } from '@angular/cdk/overlay';
import { DialogConfig, DialogBodyComponent } from '@fundamental-ngx/core/dialog';
import { MobileMode, MobileModeConfig, MobileModeBase } from '@fundamental-ngx/core/mobile-mode';
import * as i1$1 from '@fundamental-ngx/core/popover';
import { PopoverConfig, TriggerConfig } from '@fundamental-ngx/core/popover';
import { Placement, PopoverFillMode } from '@fundamental-ngx/core/shared';
import * as i3 from '@fundamental-ngx/core/content-density';
import { ContentDensityObserver } from '@fundamental-ngx/core/content-density';
import * as i1 from '@fundamental-ngx/cdk/forms';
import { ListItemComponent } from '@fundamental-ngx/core/list';

declare class GlyphMenuAddonDirective implements OnDestroy {
    /**
     *  The icon name to display. See the icon page for the list of icons
     * here: https://sap.github.io/fundamental-ngx/icon
     **/
    set glyph(glyph: string | undefined);
    /**
     * Toggle buttons always need a space, so we check if it is in a toggle button
     * */
    isInToggleButton: boolean;
    /** @hidden */
    private _menuComponent;
    /** @hidden */
    private _addonGlyphPortalOutlet$;
    /** @hidden */
    private _glyphName$;
    /** @hidden */
    private _destroyRef;
    /** @hidden */
    constructor();
    /** @hidden */
    setGlyphPortalOutlet(outlet: CdkPortalOutlet): void;
    /** @hidden */
    renderElement<ComponentType>(element: ComponentPortal<ComponentType>): Observable<ComponentRef<ComponentType>>;
    /** @hidden */
    renderElement<TemplateContext>(element: TemplatePortal<TemplateContext>): Observable<EmbeddedViewRef<TemplateContext>>;
    /** @hidden */
    renderElement(element: DomPortal): Observable<any>;
    /** @hidden */
    ngOnDestroy(): void;
    /** @hidden */
    private _addGlyphAddonToMenu;
    /** @hidden */
    private _removeGlyphAddonFromMenu;
    static ɵfac: i0.ɵɵFactoryDeclaration<GlyphMenuAddonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GlyphMenuAddonDirective, "[fdMenuAddonGlyph], [fd-menu-addon-glyph]", never, { "glyph": { "alias": "glyph"; "required": false; }; }, {}, never, never, true, never>;
}

declare class MenuAddonDirective {
    /** Whether addon is used before or after text */
    set setAddonPosition(position: 'before' | 'after');
    /** Whether is used as submenu indicator */
    submenuIndicator: boolean;
    /** Sets Aria hidden attribute */
    ariaHidden: boolean;
    /** @hidden */
    fdAddonAfterClass: boolean;
    /** @hidden */
    fdAddonBeforeClass: boolean;
    /** @hidden */
    set addonPortalOutlet(portalOutlet: CdkPortalOutlet);
    /** @hidden */
    readonly _addonGlyph: GlyphMenuAddonDirective;
    /** @hidden */
    readonly elementRef: ElementRef<HTMLElement>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuAddonDirective, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MenuAddonDirective, "fd-menu-addon", never, { "setAddonPosition": { "alias": "position"; "required": false; }; "submenuIndicator": { "alias": "submenuIndicator"; "required": false; }; "ariaHidden": { "alias": "ariaHidden"; "required": false; }; }, {}, never, never, true, [{ directive: typeof GlyphMenuAddonDirective; inputs: { "glyph": "glyph"; }; outputs: {}; }]>;
}

/**
 * The directive that represents the menu title.
 */
declare class MenuContentDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuContentDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MenuContentDirective, "[fd-menu-content]", never, {}, {}, never, never, true, never>;
}

declare class MenuItemInputDirective implements HasElementRef {
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    /**
     * This is needed to prevent the click event from bubbling up to the menu item
     * and potentially closing the menu or triggering other actions.
     */
    onInteraction($event: KeyboardEvent | MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuItemInputDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MenuItemInputDirective, "input[fd-form-control][fd-menu-item-input]", never, {}, {}, never, never, true, never>;
}

declare abstract class DefaultMenuItem {
    abstract focus(): void;
    abstract click(): void;
}

/**
 * The directive that represents the menu title.
 */
declare class MenuTitleDirective {
    /** Whether the title should truncate with ellipsis. */
    readonly truncate: i0.InputSignalWithTransform<boolean, unknown>;
    /** @hidden */
    private readonly _elementRef;
    /** Returns element title text */
    get title(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuTitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MenuTitleDirective, "[fd-menu-title]", never, { "truncate": { "alias": "truncate"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class MenuInteractiveComponent implements HasElementRef {
    /** @hidden */
    addonPortalOutlet: CdkPortalOutlet;
    /** @hidden */
    private set _addon(value);
    /** @hidden */
    tabindex: number;
    /** @hidden */
    disabled: boolean;
    /** @hidden */
    ariaControls: Nullable<string>;
    /** @hidden */
    selected: boolean;
    /** @hidden */
    ariaExpanded: Nullable<boolean>;
    /** @hidden */
    ariaHaspopup: boolean;
    /** @hidden */
    readonly fdMenuLinkClass: boolean;
    /** @hidden */
    private _input;
    /** @hidden */
    _fromSplitButton: boolean;
    /** @hidden */
    readonly elementRef: ElementRef;
    /** @hidden */
    private readonly _cdr;
    /** @hidden */
    private _startAddonInstance;
    /** @hidden */
    get startAddon(): MenuAddonDirective;
    /** @hidden */
    _handleKeydown($event: Event): void;
    /** @hidden */
    setSelected(isSelected: boolean): void;
    /** @hidden */
    setDisabled(isDisabled: boolean): void;
    /** @hidden */
    setSubmenu(hasSubmenu: boolean, itemId?: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuInteractiveComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MenuInteractiveComponent, "[fd-menu-interactive]", never, {}, {}, ["_addon", "_input"], ["*"], true, never>;
}

declare class SegmentedButtonOptionDirective<T> implements AfterViewInit, HasElementRef {
    /** @hidden */
    value: T;
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    /** @hidden */
    readonly menuItem: MenuItemComponent;
    /** @hidden */
    readonly clicked: Observable<void>;
    /** @hidden */
    readonly renderer2: Renderer2;
    /** @hidden */
    private _clicked;
    /** @hidden */
    private _dotElement;
    /** @hidden */
    private _viewInit$;
    /** @hidden */
    private _selected$;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    constructor();
    /** @hidden */
    _onClick($event: Event): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    private _createDot;
    /** @hidden */
    private _showDot;
    /** @hidden */
    private _hideDot;
    /** @hidden */
    set selected(isSelected: boolean);
    static ɵfac: i0.ɵɵFactoryDeclaration<SegmentedButtonOptionDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SegmentedButtonOptionDirective<any>, "li[fd-menu-item][fdMenuSegmentedButtonOption]", never, { "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
}

declare class SegmentedButtonHeaderDirective<T> implements AfterViewInit, HasElementRef {
    /** @hidden */
    valueComparator: (a: T, b: T) => boolean;
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    /** @hidden */
    readonly menuItem: MenuItemComponent;
    /** @hidden */
    private _cvaControl;
    /** @hidden */
    private _destroyRef;
    /** @hidden */
    private _options$;
    /** @hidden */
    constructor();
    /** @hidden */
    setOptions(options: SegmentedButtonOptionDirective<T>[]): void;
    /** @hidden */
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SegmentedButtonHeaderDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SegmentedButtonHeaderDirective<any>, "li[fd-menu-item][fdMenuSegmentedButtonHeader]", never, { "valueComparator": { "alias": "valueComparator"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.CvaDirective; inputs: { "id": "inputId"; "stateMessage": "stateMessage"; "disabled": "disabled"; "readonly": "readonly"; "name": "name"; }; outputs: {}; }]>;
}

declare const MENU_COMPONENT: InjectionToken<string[]>;
/**
 * Menu Interface to have typing and avoid circular dependency between
 * MenuComponent <==> MenuMobileComponent
 *
 * Note: MenuComponent implements InputSignal properties, which satisfy this interface
 * through structural typing even though the types don't perfectly align with MobileMode base.
 */
interface MenuInterface extends Omit<MobileMode, 'mobile' | 'mobileConfig'> {
    mobile: InputSignalWithTransform<boolean, unknown>;
    mobileConfig: InputSignal<MobileModeConfig>;
    activePath: OutputEmitterRef<MenuItemComponent[]>;
    dialogConfig: DialogConfig | null;
    isOpen: ModelSignal<boolean>;
    isOpenChange: OutputEmitterRef<boolean>;
    close(): void;
}

/**
 * The component that represents a menu.
 */
declare class MenuComponent implements MenuInterface, AfterContentInit, AfterViewInit, OnDestroy {
    /** Open submenu on hover after given milliseconds */
    readonly openOnHoverTime: i0.InputSignal<number>;
    /** Aria-label for navigation */
    readonly ariaLabel: i0.InputSignal<string | null>;
    /** Aria-Labelledby for element describing navigation */
    readonly ariaLabelledby: i0.InputSignal<string | null>;
    /** Id of the control. */
    readonly id: i0.InputSignal<string>;
    /**
     * Configuration object for popover settings.
     * When provided, these settings will be merged with individual input properties.
     * Individual inputs take precedence over config object values.
     */
    readonly config: i0.InputSignal<PopoverConfig>;
    /** Whether the menu should be displayed in mobile mode */
    readonly mobile: i0.InputSignalWithTransform<boolean, unknown>;
    /** Mobile mode configuration */
    readonly mobileConfig: i0.InputSignal<MobileModeConfig>;
    /** Menu placement */
    readonly placement: i0.InputSignal<Placement>;
    /** Whether to close menu on escape key */
    readonly closeOnEscapeKey: i0.InputSignalWithTransform<boolean, unknown>;
    /** Whether to auto-capture focus when opened */
    readonly focusAutoCapture: i0.InputSignalWithTransform<boolean, unknown>;
    /** Whether the menu is disabled */
    readonly disabled: i0.InputSignalWithTransform<boolean, unknown>;
    /** Whether to disable scrollbar */
    readonly disableScrollbar: i0.InputSignalWithTransform<boolean, unknown>;
    /** Trigger events for opening/closing */
    readonly triggers: i0.InputSignal<(string | TriggerConfig)[]>;
    /**
     * Preset options for the menu body width.
     * * `at-least` will apply a minimum width to the body equivalent to the width of the control.
     * * `equal` will apply a width to the body equivalent to the width of the control.
     * * Leave blank for no effect.
     */
    readonly fillControlMode: i0.InputSignal<PopoverFillMode | null>;
    /** Whether to close on outside click */
    readonly closeOnOutsideClick: i0.InputSignalWithTransform<boolean, unknown>;
    /** Whether to hide the arrow */
    readonly noArrow: i0.InputSignalWithTransform<boolean, unknown>;
    /** Whether the menu should trap focus within its boundaries */
    readonly focusTrapped: i0.InputSignalWithTransform<boolean, unknown>;
    /** Additional CSS classes for the menu body container */
    readonly additionalBodyClass: i0.InputSignal<string | null>;
    /** Whether to close the menu on router navigation start */
    readonly closeOnNavigation: i0.InputSignalWithTransform<boolean, unknown>;
    /** Whether to move focus back to the trigger after the menu is closed */
    readonly restoreFocusOnClose: i0.InputSignalWithTransform<boolean, unknown>;
    /** The element to which the menu overlay is attached */
    readonly appendTo: i0.InputSignal<ElementRef<any> | Element | null>;
    /** Whether position shouldn't change when the menu approaches the corner of the page */
    readonly fixedPosition: i0.InputSignalWithTransform<boolean, unknown>;
    /** CDK scroll strategy applied to the menu overlay. */
    readonly scrollStrategy: i0.InputSignal<ScrollStrategy | null>;
    /** Two-way binding for menu open state */
    readonly isOpen: i0.ModelSignal<boolean>;
    /** Emits when menu open state changes - required for MenuInterface compatibility */
    readonly isOpenChange: i0.OutputEmitterRef<boolean>;
    /** Emits array of active menu items */
    readonly activePath: i0.OutputEmitterRef<MenuItemComponent[]>;
    /** Event emitted right before the menu is being opened. */
    readonly beforeOpen: i0.OutputEmitterRef<void>;
    /** @hidden Injected dependencies using inject() function */
    readonly elementRef: ElementRef<any>;
    readonly dialogConfig: DialogConfig<any> | null;
    readonly _contentDensityObserver: ContentDensityObserver;
    /** Public getter for menu items - used by MenuService */
    get menuItems(): readonly MenuItemComponent[];
    /** @hidden */
    _navContainerRole: string;
    /** @hidden */
    _menuListContainerRole: string;
    /** @hidden Reference to the menu root template */
    protected readonly _menuRootTemplate: i0.Signal<TemplateRef<any> | undefined>;
    /** @hidden Reference to all menu Items */
    protected readonly _menuItems: i0.Signal<readonly unknown[]>;
    /** @hidden Menu item segmented item headers */
    protected readonly _segmentedButtonHeaderItems: i0.Signal<readonly SegmentedButtonHeaderDirective<any>[]>;
    /** @hidden Menu item segmented item options */
    protected readonly _segmentedButtonOptions: i0.Signal<readonly SegmentedButtonOptionDirective<any>[]>;
    /** @hidden */
    protected get hasAddons(): boolean;
    /** @hidden Reference to external menu trigger */
    private _externalTrigger;
    /** @hidden */
    private _addons;
    /** @hidden */
    private _mobileModeComponentRef;
    /** @hidden */
    private _clickEventListener;
    /** @hidden Flag to prevent circular sync between component and service */
    private _syncingIsOpen;
    /** @hidden */
    private readonly _renderer;
    private readonly _menuService;
    private readonly _popoverService;
    private readonly _injector;
    private readonly _viewContainerRef;
    private readonly _dynamicComponentService;
    private readonly _destroyRef;
    /** @hidden */
    constructor();
    /** Register addon */
    registerAddon(addon: unknown): void;
    /** Unregister addon */
    unregisterAddon(addon: unknown): void;
    /** @hidden */
    ngAfterContentInit(): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** @hidden */
    set trigger(trigger: ElementRef | null);
    get trigger(): ElementRef | null;
    /** Opens the menu */
    open(): void;
    /** Closes the menu */
    close(): void;
    /** Toggles menu open/close state */
    toggle(): void;
    /** Method called to refresh position of opened menu */
    refreshPosition(): void;
    /** @hidden */
    private _cleanUpMenuAfterClose;
    /** @hidden Select and instantiate menu view mode */
    private _setupView;
    /** @hidden */
    private _setupPopoverService;
    /** @hidden Open Menu in mobile mode */
    private _setupMobileMode;
    /**
     * @hidden
     * This is going to be removed in feature, on dialog and dynamic service component refactor
     */
    private _listenOnTriggerRefClicks;
    /**
     * @hidden
     * This is going to be removed in feature, on dialog and dynamic service component refactor
     */
    private _destroyEventListeners;
    /** @hidden */
    private _destroyMobileComponent;
    /** @hidden */
    private _focusTrigger;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MenuComponent, "fd-menu", never, { "openOnHoverTime": { "alias": "openOnHoverTime"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "ariaLabelledby"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "mobile": { "alias": "mobile"; "required": false; "isSignal": true; }; "mobileConfig": { "alias": "mobileConfig"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "closeOnEscapeKey": { "alias": "closeOnEscapeKey"; "required": false; "isSignal": true; }; "focusAutoCapture": { "alias": "focusAutoCapture"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "disableScrollbar": { "alias": "disableScrollbar"; "required": false; "isSignal": true; }; "triggers": { "alias": "triggers"; "required": false; "isSignal": true; }; "fillControlMode": { "alias": "fillControlMode"; "required": false; "isSignal": true; }; "closeOnOutsideClick": { "alias": "closeOnOutsideClick"; "required": false; "isSignal": true; }; "noArrow": { "alias": "noArrow"; "required": false; "isSignal": true; }; "focusTrapped": { "alias": "focusTrapped"; "required": false; "isSignal": true; }; "additionalBodyClass": { "alias": "additionalBodyClass"; "required": false; "isSignal": true; }; "closeOnNavigation": { "alias": "closeOnNavigation"; "required": false; "isSignal": true; }; "restoreFocusOnClose": { "alias": "restoreFocusOnClose"; "required": false; "isSignal": true; }; "appendTo": { "alias": "appendTo"; "required": false; "isSignal": true; }; "fixedPosition": { "alias": "fixedPosition"; "required": false; "isSignal": true; }; "scrollStrategy": { "alias": "scrollStrategy"; "required": false; "isSignal": true; }; "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; }, { "isOpen": "isOpenChange"; "isOpenChange": "isOpenChange"; "activePath": "activePath"; "beforeOpen": "beforeOpen"; }, ["_menuItems", "_segmentedButtonHeaderItems", "_segmentedButtonOptions"], ["*"], true, never>;
}

interface MenuNode {
    item: MenuItemComponent | null;
    parent: MenuNode | null;
    children: MenuNode[];
}
/** `null` key is used for the root node */
type MenuMap = Map<MenuItemComponent | null, MenuNode>;
declare class MenuService implements OnDestroy {
    /** Map of menu items to menu nodes */
    menuMap: MenuMap;
    /** Currently focused node */
    focusedNode: MenuNode | undefined;
    /** Collection of active menu nodes */
    activeNodePath: MenuNode[];
    /** Collection of active menu nodes */
    private _isMobileMode;
    /** @hidden */
    private _menuComponent;
    /** @hidden */
    private _destroyKeyDownHandlerListener;
    /** @hidden */
    private _destroyKeyUpHandlerListener;
    /** @hidden */
    private readonly _renderer;
    /** @hidden */
    private readonly _rtlService;
    /** @hidden */
    get _isRtl(): boolean;
    /** Reference to menu component */
    get menuComponent(): MenuComponent;
    /** Returns menu mode observable */
    get isMobileMode(): Observable<boolean>;
    /** Sets menu mode */
    setMenuMode(value: boolean): void;
    /** Sets given menu item as focused */
    setFocused(menuItem: MenuItemComponent | null): void;
    /**
     * Sets state of a given menu item
     * @param isActive - Whether should be set as active or inactive
     * @param menuItem `MenuItemComponent` that should be set as active or inactive
     */
    setActive(isActive: boolean, menuItem: MenuItemComponent | null): void;
    /**
     * Close active sibling submenu if any
     * @param menuItem to look for active siblings
     */
    setInactiveSiblingMenuItem(menuItem: MenuItemComponent): void;
    /** Initializes menu service based on given Menu Component */
    setMenuComponent(menu: MenuComponent): void;
    /** Clears Active Node Path and resets Focused Node */
    resetMenuState(): void;
    /** - Updates the structure of the menu
     *  - Validates Active Node Path
     *  - Validates Focused Node */
    rebuildMenu(): void;
    /** Adds Menu keyboard support */
    addKeyboardSupport(elementRef: ElementRef): void;
    /** Removes Menu keyboard support */
    removeKeyboardSupport(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** @hidden Returns siblings of given node */
    private _nodeSiblings;
    /** @hidden Adds given element to the Active Node Path and setts as active*/
    private _addToActivePath;
    /** @hidden Removes given element and all its successors from the Active Node Path and setts as inactive*/
    private _removeFromActivePath;
    /** @hidden Removes all elements from the Active Node Path and sets them as closed */
    private _clearActivePath;
    /** @hidden
     * - Builds Menu Nodes based on Menu Items
     * - Creates Map of the Menu Nodes */
    private _buildMenuMap;
    /** @hidden Removes active sibling of a given menu item from the Active Path */
    private _removeActiveSibling;
    /** @hidden Adds keyboard support */
    private _setKeyboardSupport;
    /** @hidden Handles keydown events: navigation and scroll prevention for Space/Enter */
    private _handleKeydown;
    /** @hidden Handles keyup events: activates focused item on Space/Enter (WCAG: activate on key release) */
    private _handleKeyup;
    /** @hidden Emits an array of active menu items */
    private _emitActivePath;
    /** @hidden Depending on direction returns closest enabled sibling of given node */
    private _closestEnabled;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MenuService>;
}

interface BaseSubmenu {
    templateRef: TemplateRef<any>;
    menuItems: MenuItemComponent[];
    menuService: MenuService;
    ariaLabel: Nullable<string>;
    ariaLabelledby: Nullable<string>;
    _menuItemsChange$: Observable<void>;
    _registerItem(item: MenuItemComponent): void;
    _unregisterItem(item: MenuItemComponent): void;
}
declare const SUBMENU: InjectionToken<BaseSubmenu>;
declare class MenuItemComponent implements DefaultMenuItem, OnInit, OnChanges, AfterContentInit, OnDestroy {
    /** Set the Menu Item as disabled/enabled */
    disabled: boolean;
    /** Menu Item id attribute value */
    itemId: string;
    /** Reference to sub-menu component */
    submenu: BaseSubmenu | undefined;
    /** Reference to the parent submenu if nested menus created dynamically */
    parentSubmenu: BaseSubmenu | undefined;
    /** Whether the menu item has a separator */
    hasSeparator: boolean;
    /** Emitted when the menu item is selected. */
    onSelect: EventEmitter<void>;
    /** @hidden Reference to the Menu Item title */
    menuItemTitle: MenuTitleDirective;
    /** @hidden Reference to the Menu Item interactive element */
    menuInteractive: MenuInteractiveComponent;
    /** @hidden Whether sub-menu is currently visible*/
    submenuVisible: boolean;
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    /** @hidden */
    menuService: MenuService | null;
    /** @hidden */
    private _subscriptions;
    /** @hidden */
    private _hoverSubscriptions;
    /** @hidden */
    private _submenu;
    /** @hidden */
    private _changeDetectorRef;
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    ngAfterContentInit(): void;
    /** @hidden */
    ngOnChanges(changes: SimpleChanges): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** Whether menu item has popup (desktop mode)  */
    get hasPopup(): boolean;
    /** Focuses Menu Item interactive element */
    focus(): void;
    /** Clicks Menu Item interactive element */
    click(): void;
    /** @hidden Sets menu item as selected/unselected based on isSelected flag */
    setSelected(isSelected: boolean, fromSplit?: boolean): void;
    /** @hidden Creates click listener on menu item interactive element */
    private _listenOnMenuLinkClick;
    /** @hidden Creates hover listeners for activating/deactivating menu item */
    private _listenOnMenuLinkHover;
    /** @hidden Initializes menu link state based on item initial state */
    private _initialiseItemState;
    /** @hidden Checks for Menu Service dependency and passes it if further */
    private _setMenuService;
    /** @hidden Listen on menu mode and set proper mode listeners */
    private _listenOnMenuMode;
    /** @hidden Updates focused menu item on outer focus */
    private _listenOnOuterFocus;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MenuItemComponent, "li[fd-menu-item]", ["fd-menu-item"], { "disabled": { "alias": "disabled"; "required": false; }; "itemId": { "alias": "itemId"; "required": false; }; "submenu": { "alias": "submenu"; "required": false; }; "parentSubmenu": { "alias": "parentSubmenu"; "required": false; }; "hasSeparator": { "alias": "hasSeparator"; "required": false; }; }, { "onSelect": "onSelect"; }, ["menuItemTitle", "menuInteractive"], ["*"], true, never>;
    static ngAcceptInputType_hasSeparator: unknown;
}
declare class SubmenuComponent implements BaseSubmenu, AfterContentInit {
    /** Aria-label for navigation */
    ariaLabel: Nullable<string>;
    /** Aria-Labelledby for element describing navigation */
    ariaLabelledby: Nullable<string>;
    /** @hidden Reference to template with Submenu items  */
    templateRef: TemplateRef<any>;
    /** @hidden Reference to Submenu MenuItems  */
    _projectedItems: QueryList<MenuItemComponent>;
    /** @hidden */
    _registeredItems: MenuItemComponent[];
    /** @hidden Reference to MenuService used by MenuItems */
    menuService: MenuService;
    /** @hidden */
    _menuItemsChange$: Subject<void>;
    /** @hidden */
    get menuItems(): MenuItemComponent[];
    /** @hidden */
    ngAfterContentInit(): void;
    /** @hidden method for manually registering item when it's not visible for @ContentChildren */
    _registerItem(item: MenuItemComponent): void;
    /** @hidden method for manually unregistering item when it's not visible for @ContentChildren */
    _unregisterItem(item: MenuItemComponent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SubmenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SubmenuComponent, "fd-submenu", ["fdSubmenu"], { "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "ariaLabelledby": { "alias": "ariaLabelledby"; "required": false; }; }, {}, ["_projectedItems"], ["*"], true, never>;
}

declare class MenuShortcutDirective implements AfterViewInit, OnDestroy {
    private _menuItem;
    private _elementRef;
    /** Hide shortcuts in mobile mode */
    hideOnMobile: boolean;
    /** @hidden */
    readonly fdMenuShortcutClass: boolean;
    /** @hidden */
    private _subscriptions;
    /** @hidden */
    constructor(_menuItem: MenuItemComponent, _elementRef: ElementRef);
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** @hidden */
    private _hideOnMobile;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuShortcutDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MenuShortcutDirective, "[fd-menu-shortcut]", never, { "hideOnMobile": { "alias": "hideOnMobile"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * The directive that represents the menu title.
 */
declare class MenuSubtitleDirective {
    /** Whether the title should truncate with ellipsis. */
    readonly truncate: i0.InputSignalWithTransform<boolean, unknown>;
    /** @hidden */
    private readonly _elementRef;
    /** Returns element title text */
    get subtitle(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuSubtitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MenuSubtitleDirective, "[fd-menu-subtitle]", never, { "truncate": { "alias": "truncate"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class MenuTriggerDirective implements OnDestroy {
    /** Set reference to Menu Component */
    set menu(menu: MenuComponent | undefined);
    /** @hidden */
    ariaHasPopup: Nullable<boolean>;
    /** @hidden */
    ariaControls: Nullable<string>;
    /** @hidden */
    ariaExpanded: Nullable<boolean>;
    /** @hidden */
    private _menuSubscription;
    /** @hidden */
    private readonly _elementRef;
    /** @hidden */
    ngOnDestroy(): void;
    private _subscribeToMenu;
    /** @hidden */
    private _unsubscribeFromMenu;
    /** @hidden */
    private _setAriaAttributes;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuTriggerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MenuTriggerDirective, "[fdMenuTrigger]", never, { "menu": { "alias": "fdMenuTrigger"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ToggleButtonDirective implements AfterViewInit {
    /** @hidden */
    private _cvaControl;
    /** @hidden */
    private _destroyRef;
    /** @hidden */
    private _interactiveItemComponent;
    /**
     * Listen on interaction events that should cause the value update
     * */
    onClick(): void;
    /** @hidden */
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToggleButtonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToggleButtonDirective, "button[fd-menu-interactive][toggle]", never, {}, {}, never, never, true, [{ directive: typeof i1.CvaDirective; inputs: { "id": "inputId"; "stateMessage": "stateMessage"; "disabled": "disabled"; "readonly": "readonly"; "name": "name"; }; outputs: {}; }]>;
}

/**
 * @deprecated
 * Use `hasSeparator` input on a `fd-menu-item` instead.
 */
declare class MenuSeparatorDirective implements HasElementRef {
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    /** @hidden */
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuSeparatorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MenuSeparatorDirective, "fd-menu-separator", never, {}, {}, never, never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class MenuModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<MenuModule, never, [typeof i1$1.PopoverModule, typeof i2.InitialFocusModule, typeof i3.ContentDensityModule, typeof GlyphMenuAddonDirective, typeof i5.PortalModule, typeof MenuComponent, typeof MenuItemComponent, typeof MenuAddonDirective, typeof MenuSeparatorDirective, typeof MenuShortcutDirective, typeof MenuInteractiveComponent, typeof MenuTitleDirective, typeof MenuSubtitleDirective, typeof MenuContentDirective, typeof SubmenuComponent, typeof MenuTriggerDirective, typeof ToggleButtonDirective, typeof SegmentedButtonHeaderDirective, typeof SegmentedButtonOptionDirective, typeof MenuItemInputDirective], [typeof MenuComponent, typeof MenuItemComponent, typeof SubmenuComponent, typeof MenuSeparatorDirective, typeof MenuShortcutDirective, typeof MenuInteractiveComponent, typeof MenuTitleDirective, typeof MenuSubtitleDirective, typeof MenuContentDirective, typeof MenuAddonDirective, typeof MenuTriggerDirective, typeof i3.ContentDensityModule, typeof GlyphMenuAddonDirective, typeof ToggleButtonDirective, typeof SegmentedButtonHeaderDirective, typeof SegmentedButtonOptionDirective, typeof MenuItemInputDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<MenuModule>;
}

declare class MenuKeyboardService {
    /** Event emitted when an item link is clicked.*/
    readonly itemClicked: Subject<number>;
    /** Whether user wants to remove keyboard handling */
    disableKeydownHandling: boolean;
    /** Function that is supposed to be called, when focus escape before list */
    focusEscapeBeforeList: () => void;
    /** Function that is supposed to be called, when focus escape after list */
    focusEscapeAfterList: () => void;
    /** Function that should be called every time, keydown event is used on some menu item,
     * it provides whole functionality for handling
     * ArrowDown - focus, ArrowUp - focus, Space bar - simulate click, Enter key - simulate click.
     * @param event KeyboardEvent
     * @param index index of items starts from 0
     * @param menuItems array of menu item directives
     * */
    keyDownHandler(event: KeyboardEvent, index: number, menuItems: DefaultMenuItem[] | ListItemComponent[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuKeyboardService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MenuKeyboardService>;
}

declare class MenuMobileComponent extends MobileModeBase<MenuInterface> implements OnInit {
    /** @hidden */
    dialogTemplate: TemplateRef<any>;
    /** Current menu title */
    title$: i0.WritableSignal<string>;
    /** Whether current menu level is submenu */
    isSubmenu$: i0.WritableSignal<boolean>;
    /** @hidden External content */
    childContent: TemplateRef<any> | null;
    /** @hidden Currently rendered menu view */
    view$: i0.WritableSignal<TemplateRef<any> | null>;
    /** @hidden Navigation icon name based on RTL */
    protected readonly navigationIcon: i0.Signal<"navigation-right-arrow" | "navigation-left-arrow">;
    /** @hidden */
    set _watch(_dialogBody: DialogBodyComponent);
    /** @hidden */
    private readonly _rtlService;
    /** @hidden */
    private readonly _menuService;
    /** @hidden */
    private readonly _injector;
    /** @hidden */
    constructor();
    /** @hidden */
    ngOnInit(): void;
    /** Closes the Dialog and Menu component */
    close(): void;
    /** Navigate back to parent level of submenu */
    backToParentLevel(): void;
    /** @hidden Opens the Dialog */
    private _openDialog;
    /** @hidden Listens on Active Path changes and updates mobile view */
    private _listenOnActivePathChange;
    /**
     * @hidden
     * Executes a function after the next render cycle.
     */
    private _executeAfterNextRender;
    /** @hidden Sets menu view, title and isSubmenu flag */
    private _setMenuView;
    /** @hidden Returns dialog title */
    private _getDialogTitle;
    /** @hidden Returns dialog content view */
    private _getMenuView;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuMobileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MenuMobileComponent, "fd-menu-mobile", never, {}, {}, never, never, true, never>;
}

export { DefaultMenuItem, GlyphMenuAddonDirective, MENU_COMPONENT, MenuAddonDirective, MenuComponent, MenuContentDirective, MenuInteractiveComponent, MenuInteractiveComponent as MenuInteractiveDirective, MenuItemComponent, MenuItemInputDirective, MenuKeyboardService, MenuMobileComponent, MenuModule, MenuSeparatorDirective as MenuSeparatorComponent, MenuSeparatorDirective, MenuService, MenuShortcutDirective, MenuSubtitleDirective, MenuTitleDirective, MenuTriggerDirective, SUBMENU, SegmentedButtonHeaderDirective, SegmentedButtonOptionDirective, SubmenuComponent, ToggleButtonDirective };
export type { BaseSubmenu, MenuInterface };
