import * as i0 from '@angular/core';
import { EventEmitter, TemplateRef, ElementRef, OnInit, AfterViewInit, QueryList } from '@angular/core';
import { Subject, Observable } from 'rxjs';
import { KeyboardSupportItemInterface } from '@fundamental-ngx/cdk/utils';
import { PopoverComponent } from '@fundamental-ngx/core/popover';

declare class UserMenuListItemComponent implements KeyboardSupportItemInterface {
    /** Event emitter for keyDown event */
    keyDown: EventEmitter<KeyboardEvent>;
    /** Event emitter for isOpenChange event that controls the submenu popover body */
    readonly isOpenChange: EventEmitter<boolean>;
    /** Event emitter for showSubmenu event */
    showSubmenu: EventEmitter<TemplateRef<any> | null>;
    /** Event emitter for updateTitle event */
    updateTitle: EventEmitter<string | null>;
    /** Unique id for the menu list item. Default is provided. */
    uniqueId: i0.InputSignal<string>;
    /** Icon name for the menu list item (optional) */
    icon: i0.InputSignal<string | undefined>;
    /** Required text for the menu list item */
    text: i0.InputSignal<string>;
    /** Unique id for the title. Default is provided. */
    textId: i0.InputSignal<string>;
    /** Whether the item has a submenu */
    hasSubmenu: i0.InputSignalWithTransform<boolean, unknown>;
    /** Template ref for user menu list item submenu */
    submenu: i0.InputSignal<TemplateRef<any> | null>;
    /** Whether the item is selected */
    selected: i0.InputSignalWithTransform<boolean, unknown>;
    /** Whether the item's submenu is open */
    isOpen: i0.WritableSignal<boolean>;
    /** Whether the item is in mobile mode */
    mobile: i0.WritableSignal<boolean>;
    /** Reference to the popover */
    popover: i0.Signal<PopoverComponent | undefined>;
    /** @hidden */
    readonly focused: Subject<UserMenuListItemComponent>;
    /** Item's tabindex */
    readonly _tabIndex$: i0.WritableSignal<number | null>;
    /** @hidden */
    readonly _elementRef: ElementRef<any>;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    private readonly _zone;
    /** @hidden */
    private _changeDetectionRef;
    /** @hidden */
    focusHandler(): void;
    /** Handles submenu selection in mobile mode */
    onShowDetailsView(): void;
    /** @hidden Support for KeyboardSupportItemInterface */
    click(): void;
    /** @hidden */
    focus(): void;
    /** @hidden */
    isOpenChangeHandle(isOpen: boolean, popover: PopoverComponent): void;
    /** @hidden */
    private _onZoneStable;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserMenuListItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UserMenuListItemComponent, "[fd-user-menu-list-item]", never, { "uniqueId": { "alias": "uniqueId"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": true; "isSignal": true; }; "textId": { "alias": "textId"; "required": false; "isSignal": true; }; "hasSubmenu": { "alias": "hasSubmenu"; "required": false; "isSignal": true; }; "submenu": { "alias": "submenu"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; }, { "keyDown": "keyDown"; "isOpenChange": "isOpenChange"; "showSubmenu": "showSubmenu"; "updateTitle": "updateTitle"; }, never, never, true, never>;
}

declare class UserMenuBodyComponent implements OnInit, AfterViewInit {
    /** @hidden */
    readonly _listItems: QueryList<UserMenuListItemComponent>;
    /**
     * Handle the navigation icon (arrow) of the Back button in RTL mode
     */
    navigationArrow$: Observable<string>;
    /**
     * Template ref of the submenu
     */
    submenu: i0.WritableSignal<TemplateRef<any> | null>;
    /**
     * The text of the selected item
     * Needed in mobile mode to update the title in the header
     */
    selectedItemTitle: i0.WritableSignal<string | null>;
    /**
     * Template ref to the header of the user menu body.
     * Needed in mobile mode
     */
    readonly bodyHeader: i0.Signal<TemplateRef<any> | undefined>;
    /** @hidden */
    private _rtlService;
    /** @hidden */
    private _refresh$;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    private readonly _keyboardSupportService;
    /** @hidden */
    onClick(event: MouseEvent): void;
    /** @hidden */
    keyDownHandler(event: KeyboardEvent): void;
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /**
     * Selects the item and sets the submenu template ref
     */
    selectItem(submenuTpl: TemplateRef<any> | null): void;
    /**
     * Updates the title of the selected item
     */
    updateTitle(title: string | null): void;
    /**
     * Clears the submenu template ref and the selected item title
     * Closes the submenu and returns to the main view
     */
    clearSubmenu(): void;
    /**
     * Closes the dialog in mobile mode
     */
    closeDialog(dialogRef: any): void;
    /** @hidden */
    private _setupInteractionListeners;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserMenuBodyComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UserMenuBodyComponent, "fd-user-menu-body", never, {}, {}, ["_listItems"], ["[fd-user-menu-header]", "[fd-user-menu-content-container]"], true, never>;
}

declare class UserMenuControlComponent {
    /** Event emitted event when control element is clicked */
    clicked: EventEmitter<void>;
    /** @hidden Saves element that is focused before dialog opened */
    private _focusedElementBeforeDialogOpened;
    /** @hidden */
    onClick(): void;
    /** @hidden */
    _focus(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserMenuControlComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UserMenuControlComponent, "fd-user-menu-control", never, {}, { "clicked": "clicked"; }, never, ["*"], true, never>;
}

declare class UserMenuComponent implements OnInit, AfterViewInit {
    /** Event thrown, when the user menu is opened or closed */
    isOpenChange: EventEmitter<boolean>;
    /** @hidden */
    userMenuControl: UserMenuControlComponent;
    /** @hidden */
    listItems: i0.Signal<readonly UserMenuListItemComponent[]>;
    /** @hidden */
    userMenuBody: i0.Signal<UserMenuBodyComponent | undefined>;
    /** Whether the user menu is in mobile mode */
    mobile: i0.InputSignalWithTransform<boolean, unknown>;
    /** Whether the user menu is open */
    isOpen: i0.WritableSignal<boolean>;
    /** @hidden */
    protected navigationArrow$: Observable<string>;
    /** @hidden */
    private _rtlService;
    /** @hidden */
    private _dialogService;
    /** @hidden */
    private _changeDetectionRef;
    /** @hidden */
    private _dialogRef;
    /** @hidden */
    constructor();
    /** @hidden */
    ngOnInit(): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** Method that opens the user menu */
    open(): void;
    /** Method that closes the user menu */
    close(): void;
    /** Method that opens the user menu in dialog (for mobile mode) */
    openDialog(dialogTemplate: TemplateRef<any>): void;
    /** @hidden */
    isOpenChangeHandle(isOpen: boolean): void;
    /** @hidden */
    private _clearSubmenu;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UserMenuComponent, "fd-user-menu", never, { "mobile": { "alias": "mobile"; "required": false; "isSignal": true; }; }, { "isOpenChange": "isOpenChange"; }, ["listItems", "userMenuBody", "userMenuControl"], ["fd-user-menu-control", "fd-user-menu-body", "fd-user-menu-footer"], true, never>;
}

declare class UserMenuFooterComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<UserMenuFooterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UserMenuFooterComponent, "fd-user-menu-footer", never, {}, {}, never, ["*"], true, never>;
}

declare class UserMenuListComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<UserMenuListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UserMenuListComponent, "fd-user-menu-list", never, {}, {}, never, ["*"], true, never>;
}

declare class UserMenuSublistComponent implements AfterViewInit {
    /** @hidden */
    _listItems: QueryList<UserMenuListItemComponent>;
    /** Whether the sublist menu items have icons */
    hasIcons: i0.InputSignalWithTransform<boolean, unknown>;
    /** @hidden */
    private _refresh$;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    private readonly _keyboardSupportService;
    /** @hidden */
    onClick(event: MouseEvent): void;
    /** @hidden */
    keyDownHandler(event: KeyboardEvent): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    private _setupInteractionListeners;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserMenuSublistComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UserMenuSublistComponent, "[fd-user-menu-sublist]", never, { "hasIcons": { "alias": "hasIcons"; "required": false; "isSignal": true; }; }, {}, ["_listItems"], ["*"], true, never>;
}

declare class UserMenuContentContainerComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<UserMenuContentContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UserMenuContentContainerComponent, "[fd-user-menu-content-container]", never, {}, {}, never, ["*"], true, never>;
}

declare class UserMenuHeaderDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<UserMenuHeaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<UserMenuHeaderDirective, "[fd-user-menu-header]", never, {}, {}, never, never, true, never>;
}

declare class UserMenuHeaderContainerDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<UserMenuHeaderContainerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<UserMenuHeaderContainerDirective, "[fd-user-menu-header-container]", never, {}, {}, never, never, true, never>;
}

declare class UserMenuUserNameDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<UserMenuUserNameDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<UserMenuUserNameDirective, "[fd-user-menu-user-name]", never, {}, {}, never, never, true, never>;
}

declare class UserMenuSublineDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<UserMenuSublineDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<UserMenuSublineDirective, "[fd-user-menu-subline]", never, {}, {}, never, never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class UserMenuModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<UserMenuModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<UserMenuModule, never, [typeof UserMenuComponent, typeof UserMenuControlComponent, typeof UserMenuBodyComponent, typeof UserMenuFooterComponent, typeof UserMenuListComponent, typeof UserMenuSublistComponent, typeof UserMenuListItemComponent, typeof UserMenuContentContainerComponent, typeof UserMenuHeaderDirective, typeof UserMenuHeaderContainerDirective, typeof UserMenuUserNameDirective, typeof UserMenuSublineDirective], [typeof UserMenuComponent, typeof UserMenuControlComponent, typeof UserMenuBodyComponent, typeof UserMenuFooterComponent, typeof UserMenuListComponent, typeof UserMenuSublistComponent, typeof UserMenuListItemComponent, typeof UserMenuContentContainerComponent, typeof UserMenuHeaderDirective, typeof UserMenuHeaderContainerDirective, typeof UserMenuUserNameDirective, typeof UserMenuSublineDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<UserMenuModule>;
}

export { UserMenuBodyComponent, UserMenuComponent, UserMenuContentContainerComponent, UserMenuControlComponent, UserMenuFooterComponent, UserMenuHeaderContainerDirective, UserMenuHeaderDirective, UserMenuListComponent, UserMenuListItemComponent, UserMenuModule, UserMenuSublineDirective, UserMenuSublistComponent, UserMenuUserNameDirective };
